From d7a1366331cd4fd1fd4be50081ece4b6b13cef4f Mon Sep 17 00:00:00 2001 From: Masato Urai Date: Thu, 17 Dec 2020 19:14:38 +0900 Subject: [PATCH 1/4] copy original files --- .../javascript/Creating DTS files From JS.md | 88 +++ .../copy/ja/javascript/Intro to JS with TS.md | 70 ++ .../copy/ja/javascript/JSDoc Reference.md | 693 ++++++++++++++++++ .../Type Checking JavaScript Files.md | 310 ++++++++ 4 files changed, 1161 insertions(+) create mode 100644 packages/documentation/copy/ja/javascript/Creating DTS files From JS.md create mode 100644 packages/documentation/copy/ja/javascript/Intro to JS with TS.md create mode 100644 packages/documentation/copy/ja/javascript/JSDoc Reference.md create mode 100644 packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md diff --git a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md new file mode 100644 index 000000000000..ebca5072748f --- /dev/null +++ b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md @@ -0,0 +1,88 @@ +--- +title: Creating .d.ts Files from .js files +layout: docs +permalink: /docs/handbook/declaration-files/dts-from-js.html +oneline: "How to add d.ts generation to JavaScript projects" +translatable: true +--- + +[With TypeScript 3.7](/docs/handbook/release-notes/typescript-3-7.html#--declaration-and---allowjs), +TypeScript added support for generating .d.ts files from JavaScript using JSDoc syntax. + +This set up means you can own the editor experience of TypeScript-powered editors without porting your project to TypeScript, or having to maintain .d.ts files in your codebase. +TypeScript supports most JSDoc tags, you can find [the reference here](/docs/handbook/type-checking-javascript-files.html#supported-jsdoc). + +## Setting up your Project to emit .d.ts files + +To add creation of .d.ts files in your project, you will need to do up-to four steps: + +- Add TypeScript to your dev dependencies +- Add a `tsconfig.json` to configure TypeScript +- Run the TypeScript compiler to generate the corresponding d.ts files for JS files +- (optional) Edit your package.json to reference the types + +### Adding TypeScript + +You can learn how to do this in our [installation page](/download). + +### TSConfig + +The TSConfig is a jsonc file which configures both your compiler flags, and declare where to find files. +In this case, you will want a file like the following: + +```json5 +{ + // Change this to match your project + include: ["src/**/*"], + + compilerOptions: { + // Tells TypeScript to read JS files, as + // normally they are ignored as source files + allowJs: true, + // Generate d.ts files + declaration: true, + // This compiler run should + // only output d.ts files + emitDeclarationOnly: true, + // Types should go into this directory. + // Removing this would place the .d.ts files + // next to the .js files + outDir: "dist", + }, +} +``` + +You can learn more about the options in the [tsconfig reference](/reference). +An alternative to using a TSConfig file is the CLI, this is the same behavior as a CLI command. + +```sh +npx typescript src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types +``` + +## Run the compiler + +You can learn how to do this in our [installation page](/download). +You want to make sure these files are included in your package if you have the files in your project's `.gitignore`. + +## Editing the package.json + +TypeScript replicates the node resolution for modules in a `package.json`, with an additional step for finding .d.ts files. +Roughly, the resolution will first check the optional `"types"` field, then the `"main"` field, and finally will try `index.d.ts` in the root. + +| Package.json | Location of default .d.ts | +| :------------------------ | :----------------------------- | +| No "types" field | checks "main", then index.d.ts | +| "types": "main.d.ts" | main.d.ts | +| "types": "./dist/main.js" | ./main/main.d.ts | + +If absent, then "main" is used + +| Package.json | Location of default .d.ts | +| :----------------------- | :------------------------ | +| No "main" field | index.d.ts | +| "main":"index.js" | index.d.ts | +| "main":"./dist/index.js" | ./dist/index.d.ts | + +## Tips + +If you'd like to write tests for your .d.ts files, try [tsd](https://github.com/SamVerschueren/tsd). diff --git a/packages/documentation/copy/ja/javascript/Intro to JS with TS.md b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md new file mode 100644 index 000000000000..4ebf0f5abca3 --- /dev/null +++ b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md @@ -0,0 +1,70 @@ +--- +title: JS Projects Utilizing TypeScript +layout: docs +permalink: /docs/handbook/intro-to-js-ts.html +oneline: How to add type checking to JavaScript files using TypeScript +translatable: true +--- + +The type system in TypeScript has different levels of strictness when working with a codebase: + +- A type-system based only on inference with JavaScript code +- Incremental typing in JavaScript [via JSDoc](/docs/handbook/jsdoc-supported-types.html) +- Using `// @ts-check` in a JavaScript file +- TypeScript code +- TypeScript with [`strict`](/tsconfig#strict) enabled + +Each step represents a move towards a safer type-system, but not every project needs that level of verification. + +## TypeScript with JavaScript + +This is when you use an editor which uses TypeScript to provide tooling like auto-complete, jump to symbol and refactoring tools like rename. +The [homepage](/) has a list of editors which have TypeScript plugins. + +## Providing Type Hints in JS via JSDoc + +In a `.js` file, types can often be inferred. When types can't be inferred, they can be specified using JSDoc syntax. + +JSDoc annotations come before a declaration will be used to set the type of that declaration. For example: + +```js twoslash +/** @type {number} */ +var x; + +x = 0; // OK +x = false; // OK?! +``` + +You can find the full list of supported JSDoc patterns [in JSDoc Supported Types](/docs/handbook/jsdoc-supported-types.html). + +## `@ts-check` + +The last line of the previous code sample would raise an error in TypeScript, but it doesn't by default in a JS project. +To enable errors in your JavaScript files add: `// @ts-check` to the first line in your `.js` files to have TypeScript raise it as an error. + +```js twoslash +// @ts-check +// @errors: 2322 +/** @type {number} */ +var x; + +x = 0; // OK +x = false; // Not OK +``` + +If you have a lot of JavaScript files you want to add errors to then you can switch to using a [`jsconfig.json`](/docs/handbook/tsconfig-json.html). +You can skip checking some files by adding a `// @ts-nocheck` comment to files. + +TypeScript may offer you errors which you disagree with, in those cases you can ignore errors on specific lines by adding `// @ts-ignore` or `// @ts-expect-error` on the preceding line. + +```js twoslash +// @ts-check +/** @type {number} */ +var x; + +x = 0; // OK +// @ts-expect-error +x = false; // Not OK +``` + +To learn more about how JavaScript is interpreted by TypeScript read [How TS Type Checks JS](/docs/handbook/type-checking-javascript-files.html) diff --git a/packages/documentation/copy/ja/javascript/JSDoc Reference.md b/packages/documentation/copy/ja/javascript/JSDoc Reference.md new file mode 100644 index 000000000000..39bd8a4daf5c --- /dev/null +++ b/packages/documentation/copy/ja/javascript/JSDoc Reference.md @@ -0,0 +1,693 @@ +--- +title: JSDoc Reference +layout: docs +permalink: /docs/handbook/jsdoc-supported-types.html +oneline: What JSDoc does TypeScript-powered JavaScript support? +translatable: true +--- + +The list below outlines which constructs are currently supported +when using JSDoc annotations to provide type information in JavaScript files. + +Note any tags which are not explicitly listed below (such as `@async`) are not yet supported. + +- `@type` +- `@param` (or `@arg` or `@argument`) +- `@returns` (or `@return`) +- `@typedef` +- `@callback` +- `@template` +- `@class` (or `@constructor`) +- `@this` +- `@extends` (or `@augments`) +- `@enum` + +#### `class` extensions + +- [Property Modifiers](#jsdoc-property-modifiers) `@public`, `@private`, `@protected`, `@readonly` + +The meaning is usually the same, or a superset, of the meaning of the tag given at [jsdoc.app](https://jsdoc.app). +The code below describes the differences and gives some example usage of each tag. + +**Note:** You can use [the playground to explore JSDoc support](/play?useJavaScript=truee=4#example/jsdoc-support). + +## `@type` + +You can use the "@type" tag and reference a type name (either primitive, defined in a TypeScript declaration, or in a JSDoc "@typedef" tag). +You can use most JSDoc types and any TypeScript type, from [the most basic like `string`](/docs/handbook/basic-types.html) to [the most advanced, like conditional types](/docs/handbook/advanced-types.html). + +```js twoslash +/** + * @type {string} + */ +var s; + +/** @type {Window} */ +var win; + +/** @type {PromiseLike} */ +var promisedString; + +// You can specify an HTML Element with DOM properties +/** @type {HTMLElement} */ +var myElement = document.querySelector(selector); +element.dataset.myData = ""; +``` + +`@type` can specify a union type — for example, something can be either a string or a boolean. + +```js twoslash +/** + * @type {(string | boolean)} + */ +var sb; +``` + +Note that parentheses are optional for union types. + +```js twoslash +/** + * @type {string | boolean} + */ +var sb; +``` + +You can specify array types using a variety of syntaxes: + +```js twoslash +/** @type {number[]} */ +var ns; +/** @type {Array.} */ +var nds; +/** @type {Array} */ +var nas; +``` + +You can also specify object literal types. +For example, an object with properties 'a' (string) and 'b' (number) uses the following syntax: + +```js twoslash +/** @type {{ a: string, b: number }} */ +var var9; +``` + +You can specify map-like and array-like objects using string and number index signatures, using either standard JSDoc syntax or TypeScript syntax. + +```js twoslash +/** + * A map-like object that maps arbitrary `string` properties to `number`s. + * + * @type {Object.} + */ +var stringToNumber; + +/** @type {Object.} */ +var arrayLike; +``` + +The preceding two types are equivalent to the TypeScript types `{ [x: string]: number }` and `{ [x: number]: any }`. The compiler understands both syntaxes. + +You can specify function types using either TypeScript or Closure syntax: + +```js twoslash +/** @type {function(string, boolean): number} Closure syntax */ +var sbn; +/** @type {(s: string, b: boolean) => number} TypeScript syntax */ +var sbn2; +``` + +Or you can just use the unspecified `Function` type: + +```js twoslash +/** @type {Function} */ +var fn7; +/** @type {function} */ +var fn6; +``` + +Other types from Closure also work: + +```js twoslash +/** + * @type {*} - can be 'any' type + */ +var star; +/** + * @type {?} - unknown type (same as 'any') + */ +var question; +``` + +### Casts + +TypeScript borrows cast syntax from Closure. +This lets you cast types to other types by adding a `@type` tag before any parenthesized expression. + +```js twoslash +/** + * @type {number | string} + */ +var numberOrString = Math.random() < 0.5 ? "hello" : 100; +var typeAssertedNumber = /** @type {number} */ (numberOrString); +``` + +### Import types + +You can also import declarations from other files using import types. +This syntax is TypeScript-specific and differs from the JSDoc standard: + +```js twoslash +// @filename: types.d.ts +export type Pet = { + name: string, +}; + +// @filename: main.js +/** + * @param p { import("./types").Pet } + */ +function walk(p) { + console.log(`Walking ${p.name}...`); +} +``` + +import types can also be used in type alias declarations: + +```js twoslash +// @filename: types.d.ts +export type Pet = { + name: string, +}; +// @filename: main.js +// ---cut--- +/** + * @typedef { import("./types").Pet } Pet + */ + +/** + * @type {Pet} + */ +var myPet; +myPet.name; +``` + +import types can be used to get the type of a value from a module if you don't know the type, or if it has a large type that is annoying to type: + +```js twoslash +// @filename: accounts.d.ts +export const userAccount = { + name: "Name", + address: "An address", + postalCode: "", + country: "", + planet: "", + system: "", + galaxy: "", + universe: "", +}; +// @filename: main.js +// ---cut--- +/** + * @type {typeof import("./accounts").userAccount } + */ +var x = require("./accounts").userAccount; +``` + +## `@param` and `@returns` + +`@param` uses the same type syntax as `@type`, but adds a parameter name. +The parameter may also be declared optional by surrounding the name with square brackets: + +```js twoslash +// Parameters may be declared in a variety of syntactic forms +/** + * @param {string} p1 - A string param. + * @param {string=} p2 - An optional param (Closure syntax) + * @param {string} [p3] - Another optional param (JSDoc syntax). + * @param {string} [p4="test"] - An optional param with a default value + * @return {string} This is the result + */ +function stringsStringStrings(p1, p2, p3, p4) { + // TODO +} +``` + +Likewise, for the return type of a function: + +```js twoslash +/** + * @return {PromiseLike} + */ +function ps() {} + +/** + * @returns {{ a: string, b: number }} - May use '@returns' as well as '@return' + */ +function ab() {} +``` + +## `@typedef`, `@callback`, and `@param` + +`@typedef` may be used to define complex types. +Similar syntax works with `@param`. + +```js twoslash +/** + * @typedef {Object} SpecialType - creates a new type named 'SpecialType' + * @property {string} prop1 - a string property of SpecialType + * @property {number} prop2 - a number property of SpecialType + * @property {number=} prop3 - an optional number property of SpecialType + * @prop {number} [prop4] - an optional number property of SpecialType + * @prop {number} [prop5=42] - an optional number property of SpecialType with default + */ + +/** @type {SpecialType} */ +var specialTypeObject; +specialTypeObject.prop3; +``` + +You can use either `object` or `Object` on the first line. + +```js twoslash +/** + * @typedef {object} SpecialType1 - creates a new type named 'SpecialType' + * @property {string} prop1 - a string property of SpecialType + * @property {number} prop2 - a number property of SpecialType + * @property {number=} prop3 - an optional number property of SpecialType + */ + +/** @type {SpecialType1} */ +var specialTypeObject1; +``` + +`@param` allows a similar syntax for one-off type specifications. +Note that the nested property names must be prefixed with the name of the parameter: + +```js twoslash +/** + * @param {Object} options - The shape is the same as SpecialType above + * @param {string} options.prop1 + * @param {number} options.prop2 + * @param {number=} options.prop3 + * @param {number} [options.prop4] + * @param {number} [options.prop5=42] + */ +function special(options) { + return (options.prop4 || 1001) + options.prop5; +} +``` + +`@callback` is similar to `@typedef`, but it specifies a function type instead of an object type: + +```js twoslash +/** + * @callback Predicate + * @param {string} data + * @param {number} [index] + * @returns {boolean} + */ + +/** @type {Predicate} */ +const ok = (s) => !(s.length % 2); +``` + +Of course, any of these types can be declared using TypeScript syntax in a single-line `@typedef`: + +```js +/** @typedef {{ prop1: string, prop2: string, prop3?: number }} SpecialType */ +/** @typedef {(data: string, index?: number) => boolean} Predicate */ +``` + +## `@template` + +You can declare generic functions with the `@template` tag: + +```js twoslash +/** + * @template T + * @param {T} x - A generic parameter that flows through to the return type + * @return {T} + */ +function id(x) { + return x; +} + +const a = id("string"); +const b = id(123); +const c = id({}); +``` + +Use comma or multiple tags to declare multiple type parameters: + +```js +/** + * @template T,U,V + * @template W,X + */ +``` + +You can also specify a type constraint before the type parameter name. +Only the first type parameter in a list is constrained: + +```js twoslash +/** + * @template {string} K - K must be a string or string literal + * @template {{ serious(): string }} Seriousalizable - must have a serious method + * @param {K} key + * @param {Seriousalizable} object + */ +function seriousalize(key, object) { + // ???? +} +``` + +Declaring generic classes or types is unsupported. + +## Classes + +Classes can be declared as ES6 classes. + +```js twoslash +class C { + /** + * @param {number} data + */ + constructor(data) { + // property types can be inferred + this.name = "foo"; + + // or set explicitly + /** @type {string | null} */ + this.title = null; + + // or simply annotated, if they're set elsewhere + /** @type {number} */ + this.size; + + this.initialize(data); // Should error, initializer expects a string + } + /** + * @param {string} s + */ + initialize = function (s) { + this.size = s.length; + }; +} + +var c = new C(0); + +// C should only be called with new, but +// because it is JavaScript, this is allowed and +// considered an 'any'. +var result = C(1); +``` + +They can also be declared as constructor functions, as described in the next section: + +## `@constructor` + +The compiler infers constructor functions based on this-property assignments, but you can make checking stricter and suggestions better if you add a `@constructor` tag: + +```js twoslash +// @checkJs +// @errors: 2345 2348 +/** + * @constructor + * @param {number} data + */ +function C(data) { + // property types can be inferred + this.name = "foo"; + + // or set explicitly + /** @type {string | null} */ + this.title = null; + + // or simply annotated, if they're set elsewhere + /** @type {number} */ + this.size; + + this.initialize(data); +} +/** + * @param {string} s + */ +C.prototype.initialize = function (s) { + this.size = s.length; +}; + +var c = new C(0); +c.size; + +var result = C(1); +``` + +> Note: Error messages only show up in JS codebases with [a JSConfig](/docs/handbook/tsconfig-json.html) and [`checkJs`](/tsconfig#checkJs) enabled. + +With `@constructor`, `this` is checked inside the constructor function `C`, so you will get suggestions for the `initialize` method and an error if you pass it a number. Your editor may also show warnings if you call `C` instead of constructing it. + +Unfortunately, this means that constructor functions that are also callable cannot use `@constructor`. + +## `@this` + +The compiler can usually figure out the type of `this` when it has some context to work with. When it doesn't, you can explicitly specify the type of `this` with `@this`: + +```js twoslash +/** + * @this {HTMLElement} + * @param {*} e + */ +function callbackForLater(e) { + this.clientHeight = parseInt(e); // should be fine! +} +``` + +## `@extends` + +When Javascript classes extend a generic base class, there is nowhere to specify what the type parameter should be. The `@extends` tag provides a place for that type parameter: + +```js twoslash +/** + * @template T + * @extends {Set} + */ +class SortableSet extends Set { + // ... +} +``` + +Note that `@extends` only works with classes. Currently, there is no way for a constructor function extend a class. + +## `@enum` + +The `@enum` tag allows you to create an object literal whose members are all of a specified type. Unlike most object literals in Javascript, it does not allow other members. + +```js twoslash +/** @enum {number} */ +const JSDocState = { + BeginningOfLine: 0, + SawAsterisk: 1, + SavingComments: 2, +}; + +JSDocState.SawAsterisk; +``` + +Note that `@enum` is quite different from, and much simpler than, TypeScript's `enum`. However, unlike TypeScript's enums, `@enum` can have any type: + +```js twoslash +/** @enum {function(number): number} */ +const MathFuncs = { + add1: (n) => n + 1, + id: (n) => -n, + sub1: (n) => n - 1, +}; + +MathFuncs.add1; +``` + +## More examples + +```js twoslash +class Foo {} +// ---cut--- +var someObj = { + /** + * @param {string} param1 - Docs on property assignments work + */ + x: function (param1) {}, +}; + +/** + * As do docs on variable assignments + * @return {Window} + */ +let someFunc = function () {}; + +/** + * And class methods + * @param {string} greeting The greeting to use + */ +Foo.prototype.sayHi = (greeting) => console.log("Hi!"); + +/** + * And arrow functions expressions + * @param {number} x - A multiplier + */ +let myArrow = (x) => x * x; + +/** + * Which means it works for stateless function components in JSX too + * @param {{a: string, b: number}} test - Some param + */ +var sfc = (test) =>
{test.a.charAt(0)}
; + +/** + * A parameter can be a class constructor, using Closure syntax. + * + * @param {{new(...args: any[]): object}} C - The class to register + */ +function registerClass(C) {} + +/** + * @param {...string} p1 - A 'rest' arg (array) of strings. (treated as 'any') + */ +function fn10(p1) {} + +/** + * @param {...string} p1 - A 'rest' arg (array) of strings. (treated as 'any') + */ +function fn9(p1) { + return p1.join(); +} +``` + +## Patterns that are known NOT to be supported + +Referring to objects in the value space as types doesn't work unless the object also creates a type, like a constructor function. + +```js twoslash +function aNormalFunction() {} +/** + * @type {aNormalFunction} + */ +var wrong; +/** + * Use 'typeof' instead: + * @type {typeof aNormalFunction} + */ +var right; +``` + +Postfix equals on a property type in an object literal type doesn't specify an optional property: + +```js twoslash +/** + * @type {{ a: string, b: number= }} + */ +var wrong; +/** + * Use postfix question on the property name instead: + * @type {{ a: string, b?: number }} + */ +var right; +``` + +Nullable types only have meaning if `strictNullChecks` is on: + +```js twoslash +/** + * @type {?number} + * With strictNullChecks: true -- number | null + * With strictNullChecks: false -- number + */ +var nullable; +``` + +You can also use a union type: + +```js twoslash +/** + * @type {number | null} + * With strictNullChecks: true -- number | null + * With strictNullChecks: false -- number + */ +var unionNullable; +``` + +Non-nullable types have no meaning and are treated just as their original type: + +```js twoslash +/** + * @type {!number} + * Just has type number + */ +var normal; +``` + +Unlike JSDoc's type system, TypeScript only allows you to mark types as containing null or not. +There is no explicit non-nullability -- if strictNullChecks is on, then `number` is not nullable. +If it is off, then `number` is nullable. + +### Unsupported tags + +TypeScript ignores any unsupported JSDoc tags. + +The following tags have open issues to support them: + +- `@const` ([issue #19672](https://github.com/Microsoft/TypeScript/issues/19672)) +- `@inheritdoc` ([issue #23215](https://github.com/Microsoft/TypeScript/issues/23215)) +- `@memberof` ([issue #7237](https://github.com/Microsoft/TypeScript/issues/7237)) +- `@yields` ([issue #23857](https://github.com/Microsoft/TypeScript/issues/23857)) +- `{@link …}` ([issue #35524](https://github.com/Microsoft/TypeScript/issues/35524)) + +## JS Class extensions + +### JSDoc Property Modifiers + +From TypeScript 3.8 onwards, you can use JSDoc to modify the properties in a class. First are the accessibility modifiers: `@public`, `@private`, and `@protected`. +These tags work exactly like `public`, `private`, and `protected` respectively work in TypeScript. + +```js twoslash +// @errors: 2341 +// @ts-check + +class Car { + constructor() { + /** @private */ + this.identifier = 100; + } + + printIdentifier() { + console.log(this.identifier); + } +} + +const c = new Car(); +console.log(c.identifier); +``` + +- `@public` is always implied and can be left off, but means that a property can be reached from anywhere. +- `@private` means that a property can only be used within the containing class. +- `@protected` means that a property can only be used within the containing class, and all derived subclasses, but not on dissimilar instances of the containing class. + +Next, we've also added the `@readonly` modifier to ensure that a property is only ever written to during initialization. + +```js twoslash +// @errors: 2540 +// @ts-check + +class Car { + constructor() { + /** @readonly */ + this.identifier = 100; + } + + printIdentifier() { + console.log(this.identifier); + } +} + +const c = new Car(); +console.log(c.identifier); +``` diff --git a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md new file mode 100644 index 000000000000..f123dcaffb21 --- /dev/null +++ b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md @@ -0,0 +1,310 @@ +--- +title: Type Checking JavaScript Files +layout: docs +permalink: /docs/handbook/type-checking-javascript-files.html +oneline: How to add type checking to JavaScript files using TypeScript +--- + +Here are some notable differences on how checking works in `.js` files compared to `.ts` files. + +## Properties are inferred from assignments in class bodies + +ES2015 does not have a means for declaring properties on classes. Properties are dynamically assigned, just like object literals. + +In a `.js` file, the compiler infers properties from property assignments inside the class body. +The type of a property is the type given in the constructor, unless it's not defined there, or the type in the constructor is undefined or null. +In that case, the type is the union of the types of all the right-hand values in these assignments. +Properties defined in the constructor are always assumed to exist, whereas ones defined just in methods, getters, or setters are considered optional. + +```js twoslash +// @checkJs +// @errors: 2322 +class C { + constructor() { + this.constructorOnly = 0; + this.constructorUnknown = undefined; + } + method() { + this.constructorOnly = false; + this.constructorUnknown = "plunkbat"; // ok, constructorUnknown is string | undefined + this.methodOnly = "ok"; // ok, but methodOnly could also be undefined + } + method2() { + this.methodOnly = true; // also, ok, methodOnly's type is string | boolean | undefined + } +} +``` + +If properties are never set in the class body, they are considered unknown. +If your class has properties that are only read from, add and then annotate a declaration in the constructor with JSDoc to specify the type. +You don't even have to give a value if it will be initialised later: + +```js twoslash +// @checkJs +// @errors: 2322 +class C { + constructor() { + /** @type {number | undefined} */ + this.prop = undefined; + /** @type {number | undefined} */ + this.count; + } +} + +let c = new C(); +c.prop = 0; // OK +c.count = "string"; +``` + +## Constructor functions are equivalent to classes + +Before ES2015, Javascript used constructor functions instead of classes. +The compiler supports this pattern and understands constructor functions as equivalent to ES2015 classes. +The property inference rules described above work exactly the same way. + +```js twoslash +// @checkJs +// @errors: 2683 2322 +function C() { + this.constructorOnly = 0; + this.constructorUnknown = undefined; +} +C.prototype.method = function () { + this.constructorOnly = false; + this.constructorUnknown = "plunkbat"; // OK, the type is string | undefined +}; +``` + +## CommonJS modules are supported + +In a `.js` file, TypeScript understands the CommonJS module format. +Assignments to `exports` and `module.exports` are recognized as export declarations. +Similarly, `require` function calls are recognized as module imports. For example: + +```js +// same as `import module "fs"` +const fs = require("fs"); + +// same as `export function readFile` +module.exports.readFile = function (f) { + return fs.readFileSync(f); +}; +``` + +The module support in Javascript is much more syntactically forgiving than TypeScript's module support. +Most combinations of assignments and declarations are supported. + +## Classes, functions, and object literals are namespaces + +Classes are namespaces in `.js` files. +This can be used to nest classes, for example: + +```js twoslash +class C {} +C.D = class {}; +``` + +And, for pre-ES2015 code, it can be used to simulate static methods: + +```js twoslash +function Outer() { + this.y = 2; +} + +Outer.Inner = function () { + this.yy = 2; +}; + +Outer.innter(); +``` + +It can also be used to create simple namespaces: + +```js twoslash +var ns = {}; +ns.C = class {}; +ns.func = function () {}; + +ns; +``` + +Other variants are allowed as well: + +```js twoslash +// IIFE +var ns = (function (n) { + return n || {}; +})(); +ns.CONST = 1; + +// defaulting to global +var assign = + assign || + function () { + // code goes here + }; +assign.extra = 1; +``` + +## Object literals are open-ended + +In a `.ts` file, an object literal that initializes a variable declaration gives its type to the declaration. +No new members can be added that were not specified in the original literal. +This rule is relaxed in a `.js` file; object literals have an open-ended type (an index signature) that allows adding and looking up properties that were not defined originally. +For instance: + +```js twoslash +var obj = { a: 1 }; +obj.b = 2; // Allowed +``` + +Object literals behave as if they have an index signature `[x:string]: any` that allows them to be treated as open maps instead of closed objects. + +Like other special JS checking behaviors, this behavior can be changed by specifying a JSDoc type for the variable. For example: + +```js twoslash +// @checkJs +// @errors: 2339 +/** @type {{a: number}} */ +var obj = { a: 1 }; +obj.b = 2; +``` + +## null, undefined, and empty array initializers are of type any or any[] + +Any variable, parameter or property that is initialized with null or undefined will have type any, even if strict null checks is turned on. +Any variable, parameter or property that is initialized with [] will have type any[], even if strict null checks is turned on. +The only exception is for properties that have multiple initializers as described above. + +```js twoslash +function Foo(i = null) { + if (!i) i = 1; + var j = undefined; + j = 2; + this.l = []; +} + +var foo = new Foo(); +foo.l.push(foo.i); +foo.l.push("end"); +``` + +## Function parameters are optional by default + +Since there is no way to specify optionality on parameters in pre-ES2015 Javascript, all function parameters in `.js` file are considered optional. +Calls with fewer arguments than the declared number of parameters are allowed. + +It is important to note that it is an error to call a function with too many arguments. + +For instance: + +```js twoslash +// @checkJs +// @strict: false +// @errors: 7006 7006 2554 +function bar(a, b) { + console.log(a + " " + b); +} + +bar(1); // OK, second argument considered optional +bar(1, 2); +bar(1, 2, 3); // Error, too many arguments +``` + +JSDoc annotated functions are excluded from this rule. +Use JSDoc optional parameter syntax (`[` `]`) to express optionality. e.g.: + +```js twoslash +/** + * @param {string} [somebody] - Somebody's name. + */ +function sayHello(somebody) { + if (!somebody) { + somebody = "John Doe"; + } + console.log("Hello " + somebody); +} + +sayHello(); +``` + +## Var-args parameter declaration inferred from use of `arguments` + +A function whose body has a reference to the `arguments` reference is implicitly considered to have a var-arg parameter (i.e. `(...arg: any[]) => any`). Use JSDoc var-arg syntax to specify the type of the arguments. + +```js twoslash +/** @param {...number} args */ +function sum(/* numbers */) { + var total = 0; + for (var i = 0; i < arguments.length; i++) { + total += arguments[i]; + } + return total; +} +``` + +## Unspecified type parameters default to `any` + +Since there is no natural syntax for specifying generic type parameters in Javascript, an unspecified type parameter defaults to `any`. + +### In extends clause + +For instance, `React.Component` is defined to have two type parameters, `Props` and `State`. +In a `.js` file, there is no legal way to specify these in the extends clause. By default the type arguments will be `any`: + +```js +import { Component } from "react"; + +class MyComponent extends Component { + render() { + this.props.b; // Allowed, since this.props is of type any + } +} +``` + +Use JSDoc `@augments` to specify the types explicitly. for instance: + +```js +import { Component } from "react"; + +/** + * @augments {Component<{a: number}, State>} + */ +class MyComponent extends Component { + render() { + this.props.b; // Error: b does not exist on {a:number} + } +} +``` + +### In JSDoc references + +An unspecified type argument in JSDoc defaults to any: + +```js twoslash +/** @type{Array} */ +var x = []; + +x.push(1); // OK +x.push("string"); // OK, x is of type Array + +/** @type{Array.} */ +var y = []; + +y.push(1); // OK +y.push("string"); // Error, string is not assignable to number +``` + +### In function calls + +A call to a generic function uses the arguments to infer the type parameters. Sometimes this process fails to infer any types, mainly because of lack of inference sources; in these cases, the type parameters will default to `any`. For example: + +```js +var p = new Promise((resolve, reject) => { + reject(); +}); + +p; // Promise; +``` + +To learn all of the features available in JSDoc, see [the reference](/docs/handbook/jsdoc-supported-types.html). From f57223dbf25d06b85ac972451ef6b4d5d856d622 Mon Sep 17 00:00:00 2001 From: Masato Urai Date: Fri, 8 Jan 2021 14:58:42 +0900 Subject: [PATCH 2/4] translate files into ja --- .../javascript/Creating DTS files From JS.md | 80 ++--- .../copy/ja/javascript/Intro to JS with TS.md | 50 ++-- .../copy/ja/javascript/JSDoc Reference.md | 276 +++++++++--------- .../Type Checking JavaScript Files.md | 154 +++++----- 4 files changed, 280 insertions(+), 280 deletions(-) diff --git a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md index ebca5072748f..205098629edf 100644 --- a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md +++ b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md @@ -1,88 +1,88 @@ --- -title: Creating .d.ts Files from .js files +title: .jsファイルから.d.tsファイルを生成する layout: docs -permalink: /docs/handbook/declaration-files/dts-from-js.html -oneline: "How to add d.ts generation to JavaScript projects" +permalink: /ja/docs/handbook/declaration-files/dts-from-js.html +oneline: "JavaScriptプロジェクトでd.tsファイルを生成する方法" translatable: true --- -[With TypeScript 3.7](/docs/handbook/release-notes/typescript-3-7.html#--declaration-and---allowjs), -TypeScript added support for generating .d.ts files from JavaScript using JSDoc syntax. +[TypeScript 3.7](/docs/handbook/release-notes/typescript-3-7.html#--declaration-and---allowjs)では、 +TypeScriptに、JSDoc構文を使ったJavaScriptから.d.tsファイルを生成するためのサポートが導入されました。 -This set up means you can own the editor experience of TypeScript-powered editors without porting your project to TypeScript, or having to maintain .d.ts files in your codebase. -TypeScript supports most JSDoc tags, you can find [the reference here](/docs/handbook/type-checking-javascript-files.html#supported-jsdoc). +この仕組みは、プロジェクトをTypeScriptに移行することなく、TypeScriptが備わったエディタの経験を自分のものにできるということを意味します。 +TypeScriptはほとんどのJSDocタグをサポートしています。リファレンスは[こちら](/docs/handbook/type-checking-javascript-files.html#supported-jsdoc)。 -## Setting up your Project to emit .d.ts files +## .d.tsファイルを出力するようにプロジェクトを設定する -To add creation of .d.ts files in your project, you will need to do up-to four steps: +プロジェクトに.d.tsファイルの作成を追加するように設定するには、最大4つのステップを実行する必要があります: -- Add TypeScript to your dev dependencies -- Add a `tsconfig.json` to configure TypeScript -- Run the TypeScript compiler to generate the corresponding d.ts files for JS files -- (optional) Edit your package.json to reference the types +- dev dependenciesにTypeScriptを追加する +- TypeScriptを設定するための`tsconfig.json`を追加する +- TypeScriptコンパイラを実行して、JSファイルに対応するd.tsファイルを生成する +- (オプション) package.jsonを編集して型を参照できるようにする -### Adding TypeScript +### TypeScriptを追加する -You can learn how to do this in our [installation page](/download). +こちらは、[インストールページ](/download)を参照してください。 ### TSConfig -The TSConfig is a jsonc file which configures both your compiler flags, and declare where to find files. -In this case, you will want a file like the following: +TSConfigはコンパイラのフラグを設定し、対象のファイルを宣言するためのjsoncファイルです。 +今回のケースでは、次のようなファイルが必要になるでしょう: ```json5 { - // Change this to match your project + // プロジェクトに合わせて変更してください include: ["src/**/*"], compilerOptions: { - // Tells TypeScript to read JS files, as - // normally they are ignored as source files + // JSファイルは通常はソースファイルとしては無視されますが、 + // ここではJSファイルを読み込むようにTypeScriptに指示します allowJs: true, - // Generate d.ts files + // d.tsファイルを生成します declaration: true, - // This compiler run should - // only output d.ts files + // コンパイラを実行すると + // d.tsファイルのみ出力されます emitDeclarationOnly: true, - // Types should go into this directory. - // Removing this would place the .d.ts files - // next to the .js files + // 型はこのディレクトリに出力されます + // このオプションを削除すると + // .jsファイルの隣に.d.tsファイルが置かれます outDir: "dist", }, } ``` -You can learn more about the options in the [tsconfig reference](/reference). -An alternative to using a TSConfig file is the CLI, this is the same behavior as a CLI command. +オプションについては、[tsconfigリファレンス](/reference)で詳しく知ることができます。 +TSConfigファイルを使用する代替手段としてCLIがあります。次は上記のTSConfigファイルと同じふるまいをするCLIコマンドです。 ```sh npx typescript src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types ``` -## Run the compiler +## コンパイラを実行する -You can learn how to do this in our [installation page](/download). -You want to make sure these files are included in your package if you have the files in your project's `.gitignore`. +実行方法については[インストールページ](/download)を参照してください。 +プロジェクトの`.gitignore`に生成されたファイルがある場合は、確実にパッケージにそれらのファイルが含まれるようにしてください。 -## Editing the package.json +## package.jsonを編集する -TypeScript replicates the node resolution for modules in a `package.json`, with an additional step for finding .d.ts files. -Roughly, the resolution will first check the optional `"types"` field, then the `"main"` field, and finally will try `index.d.ts` in the root. +TypeScriptは、`package.json`の中でNodeのモジュール解決を再現し、.d.tsファイルを見つけるためのステップを追加します。 +大まかには、ノード解決はオプションである`"types"`フィールドをチェックし、次に`"main"`フィールド、そして最後にルートの`index.d.ts`を試します。 -| Package.json | Location of default .d.ts | +| Package.json | デフォルトの.d.tsの場所 | | :------------------------ | :----------------------------- | -| No "types" field | checks "main", then index.d.ts | +| "types"フィールドがない | "main"をチェックし、次にindex.d.ts| | "types": "main.d.ts" | main.d.ts | | "types": "./dist/main.js" | ./main/main.d.ts | -If absent, then "main" is used +もし存在しなければ、次は"main"が使用されます -| Package.json | Location of default .d.ts | +| Package.json | デフォルトの.d.tsの場所 | | :----------------------- | :------------------------ | -| No "main" field | index.d.ts | +| "main"フィールドがない | index.d.ts | | "main":"index.js" | index.d.ts | | "main":"./dist/index.js" | ./dist/index.d.ts | ## Tips -If you'd like to write tests for your .d.ts files, try [tsd](https://github.com/SamVerschueren/tsd). +.d.tsファイルにテストを記述したいなら、[tsd](https://github.com/SamVerschueren/tsd)を試してみてください。 diff --git a/packages/documentation/copy/ja/javascript/Intro to JS with TS.md b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md index 4ebf0f5abca3..d14892a04331 100644 --- a/packages/documentation/copy/ja/javascript/Intro to JS with TS.md +++ b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md @@ -1,31 +1,31 @@ --- -title: JS Projects Utilizing TypeScript +title: TypeScriptを活用したJSプロジェクト layout: docs -permalink: /docs/handbook/intro-to-js-ts.html -oneline: How to add type checking to JavaScript files using TypeScript +permalink: /ja/docs/handbook/intro-to-js-ts.html +oneline: TypeScriptを使ってJavaScriptファイルに型チェックを追加する方法 translatable: true --- -The type system in TypeScript has different levels of strictness when working with a codebase: +TypeScriptの型システムがコードベースを扱う際には、様々な厳密さのレベルがあります: -- A type-system based only on inference with JavaScript code -- Incremental typing in JavaScript [via JSDoc](/docs/handbook/jsdoc-supported-types.html) -- Using `// @ts-check` in a JavaScript file -- TypeScript code -- TypeScript with [`strict`](/tsconfig#strict) enabled +- JavaScriptのコードを使った推論のみに基づく型システム +- [JSDoc](/docs/handbook/jsdoc-supported-types.html)によるJavaScriptの段階的な型付け +- JavaScriptファイルにおける`// @ts-check`の使用 +- TypeScriptコード +- [`strict`](/tsconfig#strict)を有効にしたTypeScript -Each step represents a move towards a safer type-system, but not every project needs that level of verification. +それぞれのステップはより安全な型システムへの動きを表していますが、すべてのプロジェクトがそのレベルでの検証を必要としているわけではありません。 -## TypeScript with JavaScript +## JavaScriptと併用するTypeScript -This is when you use an editor which uses TypeScript to provide tooling like auto-complete, jump to symbol and refactoring tools like rename. -The [homepage](/) has a list of editors which have TypeScript plugins. +こちらは、オートコンプリートやシンボルへのジャンプといった機能や、リネームなどのリファクタリングツールを提供するためにTypeScriptを使用しているエディタを使う場合です。 +[homepage](/)では、TypeScriptプラグインを備えているエディタをリストしています。 -## Providing Type Hints in JS via JSDoc +## JSDocを使ってJSで型ヒントを提供する -In a `.js` file, types can often be inferred. When types can't be inferred, they can be specified using JSDoc syntax. +`.js`ファイルでは、多くの場合型を推測することが可能です。型が推測できない場合、JSDoc構文を使って指定することができます。 -JSDoc annotations come before a declaration will be used to set the type of that declaration. For example: +宣言の前でJSDocのアノテーションを使い、その宣言の型を設定します。例えば: ```js twoslash /** @type {number} */ @@ -35,12 +35,12 @@ x = 0; // OK x = false; // OK?! ``` -You can find the full list of supported JSDoc patterns [in JSDoc Supported Types](/docs/handbook/jsdoc-supported-types.html). +サポートしているJSDocパターンの全リストは[JSDocがサポートする型](/docs/handbook/jsdoc-supported-types.html)にあります。 ## `@ts-check` -The last line of the previous code sample would raise an error in TypeScript, but it doesn't by default in a JS project. -To enable errors in your JavaScript files add: `// @ts-check` to the first line in your `.js` files to have TypeScript raise it as an error. +前述のコードサンプルの最後の行はTypeScriptではエラーとなりますが、JSプロジェクトではデフォルトではエラーを発生させません。 +JavaScriptファイルでエラーを有効化するには、`.js`ファイルの最初の行に`// @ts-check`を追加して、TypeScriptのエラーを発生させるようにします。 ```js twoslash // @ts-check @@ -49,13 +49,13 @@ To enable errors in your JavaScript files add: `// @ts-check` to the first line var x; x = 0; // OK -x = false; // Not OK +x = false; // エラー ``` -If you have a lot of JavaScript files you want to add errors to then you can switch to using a [`jsconfig.json`](/docs/handbook/tsconfig-json.html). -You can skip checking some files by adding a `// @ts-nocheck` comment to files. +エラーを追加したいJavaScriptファイルがたくさんある場合は、[`jsconfig.json`](/docs/handbook/tsconfig-json.html)を使用するように変更しましょう。 +ファイルに`// @ts-nocheck`コメントをつけることで、ファイルのチェックを省略することができます。 -TypeScript may offer you errors which you disagree with, in those cases you can ignore errors on specific lines by adding `// @ts-ignore` or `// @ts-expect-error` on the preceding line. +TypeScriptはあなたが納得できないようなエラーを発生させるかもしれませんが、その場合は前の行に`// @ts-ignore`または`// @ts-expect-error`を追加することで、特定の行のエラーを無視することができます。 ```js twoslash // @ts-check @@ -64,7 +64,7 @@ var x; x = 0; // OK // @ts-expect-error -x = false; // Not OK +x = false; // エラー ``` -To learn more about how JavaScript is interpreted by TypeScript read [How TS Type Checks JS](/docs/handbook/type-checking-javascript-files.html) +JavaScriptがTypeScriptによってどのように解釈されるかについて知りたい場合は、[TSの型がJSをチェックする方法](/docs/handbook/type-checking-javascript-files.html)を参照してください。 diff --git a/packages/documentation/copy/ja/javascript/JSDoc Reference.md b/packages/documentation/copy/ja/javascript/JSDoc Reference.md index 39bd8a4daf5c..ef329ad58a51 100644 --- a/packages/documentation/copy/ja/javascript/JSDoc Reference.md +++ b/packages/documentation/copy/ja/javascript/JSDoc Reference.md @@ -1,15 +1,15 @@ --- -title: JSDoc Reference +title: JSDocリファレンス layout: docs -permalink: /docs/handbook/jsdoc-supported-types.html -oneline: What JSDoc does TypeScript-powered JavaScript support? +permalink: /ja/docs/handbook/jsdoc-supported-types.html +oneline: TypeScriptを備えたJavaScriptはどのようなJSDocをサポートしているか translatable: true --- -The list below outlines which constructs are currently supported -when using JSDoc annotations to provide type information in JavaScript files. +以下のリストは、JavaScriptファイルの型情報を提供する +JSDocアノテーションにおいて、現在サポートされている構文の概要です。 -Note any tags which are not explicitly listed below (such as `@async`) are not yet supported. +以下に明示的にリストに入っていないタグ(`@async`など)はまだサポートされていないことに注意してください。 - `@type` - `@param` (or `@arg` or `@argument`) @@ -22,19 +22,19 @@ Note any tags which are not explicitly listed below (such as `@async`) are not y - `@extends` (or `@augments`) - `@enum` -#### `class` extensions +#### `class`拡張 -- [Property Modifiers](#jsdoc-property-modifiers) `@public`, `@private`, `@protected`, `@readonly` +- [プロパティ修飾子](#jsdoc-property-modifiers) `@public`、`@private`、`@protected`、`@readonly` -The meaning is usually the same, or a superset, of the meaning of the tag given at [jsdoc.app](https://jsdoc.app). -The code below describes the differences and gives some example usage of each tag. +タグの意味は通常、[jsdoc.app](https://jsdoc.app)で与えられたものと同じか、あるいはそのスーパーセットです。 +以下のコードでは、それぞれのタグの違いを説明し、使用例を示します。 -**Note:** You can use [the playground to explore JSDoc support](/play?useJavaScript=truee=4#example/jsdoc-support). +**注意:** [JSDocサポートを探るプレイグラウンド](/play?useJavaScript=truee=4#example/jsdoc-support)を使用できます ## `@type` -You can use the "@type" tag and reference a type name (either primitive, defined in a TypeScript declaration, or in a JSDoc "@typedef" tag). -You can use most JSDoc types and any TypeScript type, from [the most basic like `string`](/docs/handbook/basic-types.html) to [the most advanced, like conditional types](/docs/handbook/advanced-types.html). +"@type"タグを使用すれば、型名(プリミティブ、TypeScript宣言やJSDocの"@typedef"タグで定義されたもの)を参照することができます。 +ほとんどのJSDoc型と、[`string`のような最も基本的なもの](/docs/handbook/basic-types.html)から[Conditional Typesのような高度なもの](/docs/handbook/advanced-types.html)まで、あらゆるTypeScriptの型を使うことができます。 ```js twoslash /** @@ -48,13 +48,13 @@ var win; /** @type {PromiseLike} */ var promisedString; -// You can specify an HTML Element with DOM properties +// DOMプロパティを使ってHTML要素を指定することができます。 /** @type {HTMLElement} */ var myElement = document.querySelector(selector); element.dataset.myData = ""; ``` -`@type` can specify a union type — for example, something can be either a string or a boolean. +`@type`ではUnion型も指定できます — 例えば、次の型は文字列か真偽値のどちらかになります。 ```js twoslash /** @@ -63,7 +63,7 @@ element.dataset.myData = ""; var sb; ``` -Note that parentheses are optional for union types. +Union型の場合は、丸括弧はオプションであることに注意してください。 ```js twoslash /** @@ -72,7 +72,7 @@ Note that parentheses are optional for union types. var sb; ``` -You can specify array types using a variety of syntaxes: +様々な構文を使って配列の型を指定することができます: ```js twoslash /** @type {number[]} */ @@ -83,19 +83,19 @@ var nds; var nas; ``` -You can also specify object literal types. -For example, an object with properties 'a' (string) and 'b' (number) uses the following syntax: +オブジェクトリテラル型を指定することもできます。 +例えば、'a' (文字列) と 'b' (数値) をプロパティとして持つオブジェクトは次のような構文を使って指定します: ```js twoslash /** @type {{ a: string, b: number }} */ var var9; ``` -You can specify map-like and array-like objects using string and number index signatures, using either standard JSDoc syntax or TypeScript syntax. +JSDocの標準構文かTypeScriptの構文を使えば、文字列と数値のインデックスシグネチャを使ってマップや配列のようなオブジェクトを指定することができます。 ```js twoslash /** - * A map-like object that maps arbitrary `string` properties to `number`s. + * 任意の`string`プロパティを`number`にマッピングするマップライクなオブジェクト * * @type {Object.} */ @@ -105,18 +105,18 @@ var stringToNumber; var arrayLike; ``` -The preceding two types are equivalent to the TypeScript types `{ [x: string]: number }` and `{ [x: number]: any }`. The compiler understands both syntaxes. +前述の2つの型は、TypeScriptの型である`{ [x: string]: number }`と`{ [x: number]: any }`と等価です。コンパイラは両方の構文を理解します。 -You can specify function types using either TypeScript or Closure syntax: +関数は、TypeScriptとClosureのどちらの構文を使っても指定することができます: ```js twoslash -/** @type {function(string, boolean): number} Closure syntax */ +/** @type {function(string, boolean): number} Closure構文 */ var sbn; -/** @type {(s: string, b: boolean) => number} TypeScript syntax */ +/** @type {(s: string, b: boolean) => number} TypeScript構文 */ var sbn2; ``` -Or you can just use the unspecified `Function` type: +あるいは、型が特定されていない`Function`型を使うこともできます: ```js twoslash /** @type {Function} */ @@ -125,23 +125,23 @@ var fn7; var fn6; ``` -Other types from Closure also work: +Closureの他の型でも動作します: ```js twoslash /** - * @type {*} - can be 'any' type + * @type {*} - 'any'型になります */ var star; /** - * @type {?} - unknown type (same as 'any') + * @type {?} - 不明な型('any'と同じ) */ var question; ``` -### Casts +### キャスト -TypeScript borrows cast syntax from Closure. -This lets you cast types to other types by adding a `@type` tag before any parenthesized expression. +TypeScriptはClosureからキャスト構文を借用しています。 +これにより、丸括弧で囲まれた式の前に`@type`タグを追加することで、型を他の型にキャストすることができます。 ```js twoslash /** @@ -151,10 +151,10 @@ var numberOrString = Math.random() < 0.5 ? "hello" : 100; var typeAssertedNumber = /** @type {number} */ (numberOrString); ``` -### Import types +### インポート型 -You can also import declarations from other files using import types. -This syntax is TypeScript-specific and differs from the JSDoc standard: +インポート型を使用して他のファイルから宣言をインポートすることもできます。 +この構文はTypeScript固有のものであり、JSDocの標準とは異なります: ```js twoslash // @filename: types.d.ts @@ -171,7 +171,7 @@ function walk(p) { } ``` -import types can also be used in type alias declarations: +インポート型は型エイリアス宣言でも使用できます: ```js twoslash // @filename: types.d.ts @@ -191,7 +191,7 @@ var myPet; myPet.name; ``` -import types can be used to get the type of a value from a module if you don't know the type, or if it has a large type that is annoying to type: +型がわからない場合や型が大きくて型を付けるのが面倒な場合に、インポート型を使ってモジュールから値の型を取得することができます: ```js twoslash // @filename: accounts.d.ts @@ -213,26 +213,26 @@ export const userAccount = { var x = require("./accounts").userAccount; ``` -## `@param` and `@returns` +## `@param`と`@returns` -`@param` uses the same type syntax as `@type`, but adds a parameter name. -The parameter may also be declared optional by surrounding the name with square brackets: +`@param`は`@type`と同じ型の構文を使用しますが、パラメータ名を追加します。 +また、パラメータ名を角括弧で囲むことで、パラメータをオプションとして宣言することもできます: ```js twoslash -// Parameters may be declared in a variety of syntactic forms +// パラメータは様々な構文形式で宣言することができます /** - * @param {string} p1 - A string param. - * @param {string=} p2 - An optional param (Closure syntax) - * @param {string} [p3] - Another optional param (JSDoc syntax). - * @param {string} [p4="test"] - An optional param with a default value - * @return {string} This is the result + * @param {string} p1 - 文字列パラメータ + * @param {string=} p2 - オプションのパラメータ(Closure構文) + * @param {string} [p3] - 別のオプションのパラメータ(JSDoc構文). + * @param {string} [p4="test"] - デフォルト値を持つオプションのパラメータ + * @return {string} 結果 */ function stringsStringStrings(p1, p2, p3, p4) { // TODO } ``` -Likewise, for the return type of a function: +関数の戻り値の型についても同様です: ```js twoslash /** @@ -241,24 +241,24 @@ Likewise, for the return type of a function: function ps() {} /** - * @returns {{ a: string, b: number }} - May use '@returns' as well as '@return' + * @returns {{ a: string, b: number }} - '@returns'と同じく'@return'を使うことができます */ function ab() {} ``` -## `@typedef`, `@callback`, and `@param` +## `@typedef`、`@callback`および`@param` -`@typedef` may be used to define complex types. -Similar syntax works with `@param`. +複雑な型を定義するために`@typedef`を使うことができます。 +`@param`を使った同様の構文でも動作します。 ```js twoslash /** - * @typedef {Object} SpecialType - creates a new type named 'SpecialType' - * @property {string} prop1 - a string property of SpecialType - * @property {number} prop2 - a number property of SpecialType - * @property {number=} prop3 - an optional number property of SpecialType - * @prop {number} [prop4] - an optional number property of SpecialType - * @prop {number} [prop5=42] - an optional number property of SpecialType with default + * @typedef {Object} SpecialType - 'SpecialType'という名前の新しい型を作成 + * @property {string} prop1 - SpecialTypeの文字列プロパティ + * @property {number} prop2 - SpecialTypeの数値プロパティ + * @property {number=} prop3 - SpecialTypeのオプションの数値プロパティ + * @prop {number} [prop4] - SpecialTypeのオプションの数値プロパティ + * @prop {number} [prop5=42] - SpecialTypeのデフォルト値を持つオプションの数値プロパティ */ /** @type {SpecialType} */ @@ -266,26 +266,26 @@ var specialTypeObject; specialTypeObject.prop3; ``` -You can use either `object` or `Object` on the first line. +最初の行には、`object`あるいは`Object`のどちらかを使うことができます。 ```js twoslash /** - * @typedef {object} SpecialType1 - creates a new type named 'SpecialType' - * @property {string} prop1 - a string property of SpecialType - * @property {number} prop2 - a number property of SpecialType - * @property {number=} prop3 - an optional number property of SpecialType + * @typedef {object} SpecialType1 - 'SpecialType'という名前の新しい型を作成 + * @property {string} prop1 - SpecialTypeの文字列プロパティ + * @property {number} prop2 - SpecialTypeの数値プロパティ + * @property {number=} prop3 - SpecialTypeのオプションの数値プロパティ */ /** @type {SpecialType1} */ var specialTypeObject1; ``` -`@param` allows a similar syntax for one-off type specifications. -Note that the nested property names must be prefixed with the name of the parameter: +`@param`を使えば、同様の構文で一回限りの型を指定することができます。 +ネストされたプロパティ名の前には、パラメータ名をつけなければならないことに注意してください: ```js twoslash /** - * @param {Object} options - The shape is the same as SpecialType above + * @param {Object} options - 形状は上記のSpecialTypeと同じ * @param {string} options.prop1 * @param {number} options.prop2 * @param {number=} options.prop3 @@ -297,7 +297,7 @@ function special(options) { } ``` -`@callback` is similar to `@typedef`, but it specifies a function type instead of an object type: +`@callback`は`@typedef`に似ていますが、オブジェクト型ではなく関数型を指定します: ```js twoslash /** @@ -311,7 +311,7 @@ function special(options) { const ok = (s) => !(s.length % 2); ``` -Of course, any of these types can be declared using TypeScript syntax in a single-line `@typedef`: +もちろん、これらの型はすべてTypeScriptの構文を使って一行の`@typedef`で宣言することができます: ```js /** @typedef {{ prop1: string, prop2: string, prop3?: number }} SpecialType */ @@ -320,12 +320,12 @@ Of course, any of these types can be declared using TypeScript syntax in a singl ## `@template` -You can declare generic functions with the `@template` tag: +ジェネリクス関数は`@template`タグを使って宣言することができます: ```js twoslash /** * @template T - * @param {T} x - A generic parameter that flows through to the return type + * @param {T} x - 戻り値に流用するジェネリクスパラメータ * @return {T} */ function id(x) { @@ -337,7 +337,7 @@ const b = id(123); const c = id({}); ``` -Use comma or multiple tags to declare multiple type parameters: +複数の型パラメータを宣言するには、コンマか複数のタグを使用します: ```js /** @@ -346,13 +346,13 @@ Use comma or multiple tags to declare multiple type parameters: */ ``` -You can also specify a type constraint before the type parameter name. -Only the first type parameter in a list is constrained: +型パラメータ名の前に、型制約を指定することもできます。 +リストにある最初の型パラメータだけが、制約を受けます: ```js twoslash /** - * @template {string} K - K must be a string or string literal - * @template {{ serious(): string }} Seriousalizable - must have a serious method + * @template {string} K - Kは文字列または文字列リテラルでなければなりません + * @template {{ serious(): string }} Seriousalizable - seriousメソッドを持っていなければなりません * @param {K} key * @param {Seriousalizable} object */ @@ -361,11 +361,11 @@ function seriousalize(key, object) { } ``` -Declaring generic classes or types is unsupported. +ジェネリクスのクラスや型の宣言はサポートされていません。 -## Classes +## クラス -Classes can be declared as ES6 classes. +クラスはES6のクラスとして宣言することができます。 ```js twoslash class C { @@ -373,18 +373,18 @@ class C { * @param {number} data */ constructor(data) { - // property types can be inferred + // プロパティの型は推測されます this.name = "foo"; - // or set explicitly + // あるいは、明示的に設定することもできます /** @type {string | null} */ this.title = null; - // or simply annotated, if they're set elsewhere + // また、他のところで設定されている場合は、単に型注釈をつけることもできます /** @type {number} */ this.size; - this.initialize(data); // Should error, initializer expects a string + this.initialize(data); // initializerは文字列を受け取るので、エラーになるべきです } /** * @param {string} s @@ -396,17 +396,17 @@ class C { var c = new C(0); -// C should only be called with new, but -// because it is JavaScript, this is allowed and -// considered an 'any'. +// Cはnewを使用した場合のみ呼び出されるべきですが、 +// JavaScriptでは、以下は許可されており、 +// これは'any'型とみなされます。 var result = C(1); ``` -They can also be declared as constructor functions, as described in the next section: +次の節で説明するように、コンストラクタ関数として宣言することもできます: ## `@constructor` -The compiler infers constructor functions based on this-property assignments, but you can make checking stricter and suggestions better if you add a `@constructor` tag: +コンパイラはthisプロパティの代入に基づいてコンストラクタ関数を推測しますが、`@constructor`タグを追加すればより厳密なチェックとより良い提案を受けることができます: ```js twoslash // @checkJs @@ -416,14 +416,14 @@ The compiler infers constructor functions based on this-property assignments, bu * @param {number} data */ function C(data) { - // property types can be inferred + // プロパティの型は推測されます this.name = "foo"; - // or set explicitly + // あるいは、明示的に設定することもできます /** @type {string | null} */ this.title = null; - // or simply annotated, if they're set elsewhere + // また、他のところで設定されている場合は、単に型注釈をつけることもできます /** @type {number} */ this.size; @@ -442,15 +442,15 @@ c.size; var result = C(1); ``` -> Note: Error messages only show up in JS codebases with [a JSConfig](/docs/handbook/tsconfig-json.html) and [`checkJs`](/tsconfig#checkJs) enabled. +> 注意: エラーメッセージが表示されるのは、[JSConfig](/docs/handbook/tsconfig-json.html)と[`checkJs`](/tsconfig#checkJs)が有効化されているJSコードベースのみです。 -With `@constructor`, `this` is checked inside the constructor function `C`, so you will get suggestions for the `initialize` method and an error if you pass it a number. Your editor may also show warnings if you call `C` instead of constructing it. +`@constructor`では、`this`はコンストラクタ関数`C`の内部でチェックされるので、数値を渡すと`initialize`メソッドへの提案とエラーが表示されます。また、コンストラクタの代わりに`C`を呼び出すと、エディタが警告を表示することもあります。 -Unfortunately, this means that constructor functions that are also callable cannot use `@constructor`. +残念ながら、これは呼び出しも可能なコンストラクタ関数では、`@constructor`を使用できないことを意味します。 ## `@this` -The compiler can usually figure out the type of `this` when it has some context to work with. When it doesn't, you can explicitly specify the type of `this` with `@this`: +コンパイラは通常、`this`が用いられるコンテクストから`this`の型を推測することができます。推測できない場合、`@this`を使って明示的に`this`の型を指定することができます: ```js twoslash /** @@ -458,13 +458,13 @@ The compiler can usually figure out the type of `this` when it has some context * @param {*} e */ function callbackForLater(e) { - this.clientHeight = parseInt(e); // should be fine! + this.clientHeight = parseInt(e); // 大丈夫なはず！ } ``` ## `@extends` -When Javascript classes extend a generic base class, there is nowhere to specify what the type parameter should be. The `@extends` tag provides a place for that type parameter: +JavaScriptクラスがジェネリクスの基底クラスを拡張するとき、型パラメータが何であるべきかを指定するところがありません。`@extends`タグはそのような型パラメータを指定する方法を提供しています: ```js twoslash /** @@ -476,11 +476,11 @@ class SortableSet extends Set { } ``` -Note that `@extends` only works with classes. Currently, there is no way for a constructor function extend a class. +`@extends`は、クラスに対してのみ動作することに注意してください。現在、コンストラクタ関数がクラスを拡張する方法はありません。 ## `@enum` -The `@enum` tag allows you to create an object literal whose members are all of a specified type. Unlike most object literals in Javascript, it does not allow other members. +`@enum`タグを使うと、すべてのメンバが指定された型であるオブジェクトリテラルを作成することができます。JavaScriptのたいていのオブジェクトリテラルとは異なり、明示されていないメンバは使用できません。 ```js twoslash /** @enum {number} */ @@ -493,7 +493,7 @@ const JSDocState = { JSDocState.SawAsterisk; ``` -Note that `@enum` is quite different from, and much simpler than, TypeScript's `enum`. However, unlike TypeScript's enums, `@enum` can have any type: +注意すべき点は、`@enum`はTypeScriptの`enum`とは大きく異なっており、とてもシンプルです。一方で、TypeScriptの`enum`とは違って、`@enum`は任意の型を持つことができます: ```js twoslash /** @enum {function(number): number} */ @@ -506,65 +506,65 @@ const MathFuncs = { MathFuncs.add1; ``` -## More examples +## その他の例 ```js twoslash class Foo {} // ---cut--- var someObj = { /** - * @param {string} param1 - Docs on property assignments work + * @param {string} param1 - プロパティの割り当てに関する仕様は、 */ x: function (param1) {}, }; /** - * As do docs on variable assignments + * 変数の代入や * @return {Window} */ let someFunc = function () {}; /** - * And class methods - * @param {string} greeting The greeting to use + * クラスメソッド、 + * @param {string} greeting 使用する挨拶 */ Foo.prototype.sayHi = (greeting) => console.log("Hi!"); /** - * And arrow functions expressions - * @param {number} x - A multiplier + * アロー関数式でも同様に動作します + * @param {number} x - 乗数 */ let myArrow = (x) => x * x; /** - * Which means it works for stateless function components in JSX too - * @param {{a: string, b: number}} test - Some param + * つまり、JSXのステートレス関数コンポーネントでも動作するということです + * @param {{a: string, b: number}} test - いくつかのパラメータ */ var sfc = (test) =>
{test.a.charAt(0)}
; /** - * A parameter can be a class constructor, using Closure syntax. + * パラメータには、Closure構文を使用して、クラスのコンストラクタを使用することができます。 * - * @param {{new(...args: any[]): object}} C - The class to register + * @param {{new(...args: any[]): object}} C - 登録するクラス */ function registerClass(C) {} /** - * @param {...string} p1 - A 'rest' arg (array) of strings. (treated as 'any') + * @param {...string} p1 - 文字列の'レストパラメータ'(配列)引数 ('any'として扱われます) */ function fn10(p1) {} /** - * @param {...string} p1 - A 'rest' arg (array) of strings. (treated as 'any') + * @param {...string} p1 - 文字列の'レストパラメータ'(配列)引数 ('any'として扱われます) */ function fn9(p1) { return p1.join(); } ``` -## Patterns that are known NOT to be supported +## サポートされていないことが知られているパターン -Referring to objects in the value space as types doesn't work unless the object also creates a type, like a constructor function. +コンストラクタ関数のようにオブジェクトも型を作らない限り、値空間のオブジェクトを型として参照することはできません。 ```js twoslash function aNormalFunction() {} @@ -573,13 +573,13 @@ function aNormalFunction() {} */ var wrong; /** - * Use 'typeof' instead: + * 'typeof'を代わりに使用します: * @type {typeof aNormalFunction} */ var right; ``` -Postfix equals on a property type in an object literal type doesn't specify an optional property: +オブジェクトリテラル型のプロパティ型の後ろに等号をつけても、オプションのプロパティにはなりません: ```js twoslash /** @@ -587,53 +587,53 @@ Postfix equals on a property type in an object literal type doesn't specify an o */ var wrong; /** - * Use postfix question on the property name instead: + * 代わりにプロパティ名の前にクエスチョンマークを付けます: * @type {{ a: string, b?: number }} */ var right; ``` -Nullable types only have meaning if `strictNullChecks` is on: +`strictNullChecks`が有効化されている場合のみ、Nullable型は動作します: ```js twoslash /** * @type {?number} - * With strictNullChecks: true -- number | null - * With strictNullChecks: false -- number + * strictNullChecks: trueの場合 -- number | null + * strictNullChecks: falseの場合 -- number */ var nullable; ``` -You can also use a union type: +Union型も使うことができます: ```js twoslash /** * @type {number | null} - * With strictNullChecks: true -- number | null - * With strictNullChecks: false -- number + * strictNullChecks: trueの場合 -- number | null + * strictNullChecks: falseの場合 -- number */ var unionNullable; ``` -Non-nullable types have no meaning and are treated just as their original type: +非Nullable型は意味を持たず、元の型と同じように扱われます: ```js twoslash /** * @type {!number} - * Just has type number + * 数値型だけをもちます */ var normal; ``` -Unlike JSDoc's type system, TypeScript only allows you to mark types as containing null or not. -There is no explicit non-nullability -- if strictNullChecks is on, then `number` is not nullable. -If it is off, then `number` is nullable. +JSDocの型システムとは異なり、TypeScriptは型にnullが含まれるかどうか記すことしかできません。 +明示的な非Nullable型はありません -- strictNullChecksが有効なら、`number`はNullableではありません。 +有効でないなら、`number`はNullableです。 -### Unsupported tags +### サポートされていないタグ -TypeScript ignores any unsupported JSDoc tags. +TypeScriptはサポートされていないJSDocタグを無視します。 -The following tags have open issues to support them: +以下のタグは、サポートを目標としたオープンIssueがあります: - `@const` ([issue #19672](https://github.com/Microsoft/TypeScript/issues/19672)) - `@inheritdoc` ([issue #23215](https://github.com/Microsoft/TypeScript/issues/23215)) @@ -641,12 +641,12 @@ The following tags have open issues to support them: - `@yields` ([issue #23857](https://github.com/Microsoft/TypeScript/issues/23857)) - `{@link …}` ([issue #35524](https://github.com/Microsoft/TypeScript/issues/35524)) -## JS Class extensions +## JSクラスの拡張 -### JSDoc Property Modifiers +### JSDocプロパティ修飾子 -From TypeScript 3.8 onwards, you can use JSDoc to modify the properties in a class. First are the accessibility modifiers: `@public`, `@private`, and `@protected`. -These tags work exactly like `public`, `private`, and `protected` respectively work in TypeScript. +TypeScript 3.8以降、JSDocを使ってクラスプロパティを修飾することができます。まずは、アクセシビリティ修飾子`@public`、`@private`、`@protected`です。 +これらのタグは、TypeScriptの`public`、`private`、`protected`とそれぞれ同じように動作します。 ```js twoslash // @errors: 2341 @@ -667,11 +667,11 @@ const c = new Car(); console.log(c.identifier); ``` -- `@public` is always implied and can be left off, but means that a property can be reached from anywhere. -- `@private` means that a property can only be used within the containing class. -- `@protected` means that a property can only be used within the containing class, and all derived subclasses, but not on dissimilar instances of the containing class. +- `@public`は常に暗示的であり、省略可能です。どこからでもプロパティにアクセスできることを意味します。 +- `@private`は、そのプロパティが含まれるクラス内でのみ使用可能であることを意味します。 +- `@protected`は、そのプロパティが含まれるクラスと、そのクラスの派生クラス内で使用可能ですが、クラスのインスタンスからはアクセスできません。 -Next, we've also added the `@readonly` modifier to ensure that a property is only ever written to during initialization. +次に、`@readonly`修飾子を追加しました。これを使用すると、プロパティが初期化時にのみ書き込まれることが保証されます。 ```js twoslash // @errors: 2540 diff --git a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md index f123dcaffb21..23e61ce1b51e 100644 --- a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md +++ b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md @@ -1,20 +1,20 @@ --- -title: Type Checking JavaScript Files +title: JavaScriptファイルの型チェック layout: docs -permalink: /docs/handbook/type-checking-javascript-files.html -oneline: How to add type checking to JavaScript files using TypeScript +permalink: /ja/docs/handbook/type-checking-javascript-files.html +oneline: TypeScriptを使ってJavaScriptファイルに型チェックを追加する方法 --- -Here are some notable differences on how checking works in `.js` files compared to `.ts` files. +ここでは、`.js`ファイルを`.ts`ファイルと比較したときの、チェック機能の違いについて注目すべき点をいくつか挙げます。 -## Properties are inferred from assignments in class bodies +## プロパティはクラス本体における代入から推測される -ES2015 does not have a means for declaring properties on classes. Properties are dynamically assigned, just like object literals. +ES2015には、クラスのプロパティを宣言する手段がありません。プロパティはオブジェクトリテラルのように、動的に代入されます。 -In a `.js` file, the compiler infers properties from property assignments inside the class body. -The type of a property is the type given in the constructor, unless it's not defined there, or the type in the constructor is undefined or null. -In that case, the type is the union of the types of all the right-hand values in these assignments. -Properties defined in the constructor are always assumed to exist, whereas ones defined just in methods, getters, or setters are considered optional. +`.js`ファイルでは、コンパイラはクラス本体のプロパティの代入からプロパティを推測します。 +コンストラクタで型が定義されていない場合や、コンストラクタでの型がundefinedまたはnullである場合を除いて、プロパティの型はコンストラクタ内で与えられた型になります。 +プロパティの型がコンストラクタ内で与えられない場合、プロパティの型は、プロパティの代入式におけるすべての右辺の値の型によるUnion型となります。 +メソッドやgetter、setter内で定義されたプロパティはオプションとみなされるのに対して、コンストラクタで定義されたプロパティは常に存在するものとみなされます。 ```js twoslash // @checkJs @@ -26,18 +26,18 @@ class C { } method() { this.constructorOnly = false; - this.constructorUnknown = "plunkbat"; // ok, constructorUnknown is string | undefined - this.methodOnly = "ok"; // ok, but methodOnly could also be undefined + this.constructorUnknown = "plunkbat"; // ok、constructorUnknown は string | undefined です + this.methodOnly = "ok"; // ok、しかし、methodOnlyはundefinedの可能性もあります } method2() { - this.methodOnly = true; // also, ok, methodOnly's type is string | boolean | undefined + this.methodOnly = true; // こちらもokです。methodOnlyの型は string | boolean | undefined です } } ``` -If properties are never set in the class body, they are considered unknown. -If your class has properties that are only read from, add and then annotate a declaration in the constructor with JSDoc to specify the type. -You don't even have to give a value if it will be initialised later: +クラス本体でプロパティが設定されていない場合、そのプロパティは未知のものとみなされます。 +クラスプロパティが読み取り専用ならば、コンストラクタにプロパティを追加した後に、型指定のためJSDocを使って型宣言の注釈を付けます。 +後で初期化されるのであれば、値を指定する必要さえありません: ```js twoslash // @checkJs @@ -56,11 +56,11 @@ c.prop = 0; // OK c.count = "string"; ``` -## Constructor functions are equivalent to classes +## コンストラクタ関数はクラスと同等である -Before ES2015, Javascript used constructor functions instead of classes. -The compiler supports this pattern and understands constructor functions as equivalent to ES2015 classes. -The property inference rules described above work exactly the same way. +ES2015以前のJavascriptでは、クラスの代わりにコンストラクタ関数が使われていました。 +コンパイラはこうしたパターンをサポートしており、コンストラクタ関数をES2015のクラスと同等のものとして理解します。 +上記で説明したプロパティの推論ルールも全く同じように動作します。 ```js twoslash // @checkJs @@ -71,40 +71,40 @@ function C() { } C.prototype.method = function () { this.constructorOnly = false; - this.constructorUnknown = "plunkbat"; // OK, the type is string | undefined + this.constructorUnknown = "plunkbat"; // OK、型はstring | undefinedです }; ``` -## CommonJS modules are supported +## CommonJSモジュールがサポートされている -In a `.js` file, TypeScript understands the CommonJS module format. -Assignments to `exports` and `module.exports` are recognized as export declarations. -Similarly, `require` function calls are recognized as module imports. For example: +`.js`ファイルでは、TypeScriptはCommonJSモジュールフォーマットをサポートしています。 +`exports`や`module.exports`への代入は、エクスポート宣言として認識されていますし、 +同様に`require`関数の呼び出しも、モジュールインポートとして認識されます。例えば: ```js -// same as `import module "fs"` +// `import module "fs"`と同じ const fs = require("fs"); -// same as `export function readFile` +// `export function readFile`と同じ module.exports.readFile = function (f) { return fs.readFileSync(f); }; ``` -The module support in Javascript is much more syntactically forgiving than TypeScript's module support. -Most combinations of assignments and declarations are supported. +JavaScriptのモジュールサポートは、TypeScriptのモジュールサポートよりも構文的に寛容です。 +ほとんどの代入と宣言の組み合わせがサポートされています。 -## Classes, functions, and object literals are namespaces +## クラス、関数、オブジェクトリテラルは名前空間を作る -Classes are namespaces in `.js` files. -This can be used to nest classes, for example: +クラスは`.js`ファイルにおける名前空間を作成します。 +これを利用してクラスをネストすることができます。例えば: ```js twoslash class C {} C.D = class {}; ``` -And, for pre-ES2015 code, it can be used to simulate static methods: +また、ES2015以前のコードのための擬似的な静的メソッドとしても利用できます: ```js twoslash function Outer() { @@ -118,7 +118,7 @@ Outer.Inner = function () { Outer.innter(); ``` -It can also be used to create simple namespaces: +シンプルな名前空間を作成することにも使えます: ```js twoslash var ns = {}; @@ -128,39 +128,39 @@ ns.func = function () {}; ns; ``` -Other variants are allowed as well: +その他の変形も同様に可能です: ```js twoslash -// IIFE +// IIFE (即時実行関数式) var ns = (function (n) { return n || {}; })(); ns.CONST = 1; -// defaulting to global +// グローバル名前空間をデフォルトにする var assign = assign || function () { - // code goes here + // ここにコードを記述する }; assign.extra = 1; ``` -## Object literals are open-ended +## オブジェクトリテラルは無制限型である -In a `.ts` file, an object literal that initializes a variable declaration gives its type to the declaration. -No new members can be added that were not specified in the original literal. -This rule is relaxed in a `.js` file; object literals have an open-ended type (an index signature) that allows adding and looking up properties that were not defined originally. -For instance: +`.ts`ファイルにおいて、変数宣言を初期化するオブジェクトリテラルは、宣言に型を与えます。 +元のリテラルで指定されていない新しいメンバを追加することはできません。 +このルールは`.js`ファイルでは緩和されています; オブジェクトリテラルには無制限型(インデックスシグネチャ)があり、元々定義されていないプロパティを追加したり検索したりすることができます。 +例えば: ```js twoslash var obj = { a: 1 }; -obj.b = 2; // Allowed +obj.b = 2; // これは許容されます ``` -Object literals behave as if they have an index signature `[x:string]: any` that allows them to be treated as open maps instead of closed objects. +オブジェクトリテラルはインデックスシグネチャ `[x:string]: any` を持っているかのように動作し、制限をもつオブジェクトではなく無制限のマップとして扱うことができます。 -Like other special JS checking behaviors, this behavior can be changed by specifying a JSDoc type for the variable. For example: +他の特別なJSチェックの動作と同様に、変数にJSDoc型を指定することでこの動作を変更することができます。例えば: ```js twoslash // @checkJs @@ -170,11 +170,11 @@ var obj = { a: 1 }; obj.b = 2; ``` -## null, undefined, and empty array initializers are of type any or any[] +## null、undefined、空の配列の初期化子はanyまたはany[]型を付ける -Any variable, parameter or property that is initialized with null or undefined will have type any, even if strict null checks is turned on. -Any variable, parameter or property that is initialized with [] will have type any[], even if strict null checks is turned on. -The only exception is for properties that have multiple initializers as described above. +nullまたはundefinedで初期化されたパラメータやプロパティは、厳密なnullチェックが有効化されていたとしても、any型になります。 +[]で初期化されたパラメータやプロパティは、厳密なnullチェックが有効化されていたとしても、any[]型になります。 +唯一の例外は上記で説明した初期化子を複数持つプロパティの場合です。 ```js twoslash function Foo(i = null) { @@ -189,14 +189,14 @@ foo.l.push(foo.i); foo.l.push("end"); ``` -## Function parameters are optional by default +## 関数のパラメータはデフォルトではオプションである -Since there is no way to specify optionality on parameters in pre-ES2015 Javascript, all function parameters in `.js` file are considered optional. -Calls with fewer arguments than the declared number of parameters are allowed. +ES2015以前のJavascriptでは、パラメータがオプションかどうかを指定する方法がないため、`.js`ファイルの関数パラメータはすべてオプションとみなされます。 +宣言されたパラメータ数よりも少ない引数で、関数を呼び出すことが可能です。 -It is important to note that it is an error to call a function with too many arguments. +宣言された数より、引数の数が多い関数を呼び出すとエラーになるので注意が必要です。 -For instance: +例えば: ```js twoslash // @checkJs @@ -206,17 +206,17 @@ function bar(a, b) { console.log(a + " " + b); } -bar(1); // OK, second argument considered optional +bar(1); // OK、二番目の引数はオプションとみなされます bar(1, 2); -bar(1, 2, 3); // Error, too many arguments +bar(1, 2, 3); // エラー、引数が多すぎます ``` -JSDoc annotated functions are excluded from this rule. -Use JSDoc optional parameter syntax (`[` `]`) to express optionality. e.g.: +JSDocの注釈付き関数はこの規則から除外されます。 +オプションであることを表すには、JSDocのオプションパラメータ構文(`[` `]`)を使用します。例えば: ```js twoslash /** - * @param {string} [somebody] - Somebody's name. + * @param {string} [somebody] - 誰かの名前 */ function sayHello(somebody) { if (!somebody) { @@ -228,9 +228,9 @@ function sayHello(somebody) { sayHello(); ``` -## Var-args parameter declaration inferred from use of `arguments` +## 可変長引数のパラメータ宣言は、`arguments`の使い方から推測される -A function whose body has a reference to the `arguments` reference is implicitly considered to have a var-arg parameter (i.e. `(...arg: any[]) => any`). Use JSDoc var-arg syntax to specify the type of the arguments. +関数本体で`arguments`を参照すると、暗黙的に可変長引数パラメータ(例: `(...arg: any[]) => any`)を持っているとみなされます。JSDocの可変長引数構文を使って、引数の型を指定します。 ```js twoslash /** @param {...number} args */ @@ -243,26 +243,26 @@ function sum(/* numbers */) { } ``` -## Unspecified type parameters default to `any` +## 未指定の型パラメータのデフォルトは`any`である -Since there is no natural syntax for specifying generic type parameters in Javascript, an unspecified type parameter defaults to `any`. +Javascriptにはジェネリクス型のパラメータを指定するための標準構文がないため、未指定の型パラメータはデフォルトで`any`となります。 -### In extends clause +### extends句において -For instance, `React.Component` is defined to have two type parameters, `Props` and `State`. -In a `.js` file, there is no legal way to specify these in the extends clause. By default the type arguments will be `any`: +例えば、`React.Component`は、`Props`と`State`の2つの型パラメータを持つように定義されています。 +`.js`ファイルでは、extends句でこれらを指定する正当な方法はありません。型引数はデフォルトで`any`となります: ```js import { Component } from "react"; class MyComponent extends Component { render() { - this.props.b; // Allowed, since this.props is of type any + this.props.b; // this.propsはany型なので、許可されています } } ``` -Use JSDoc `@augments` to specify the types explicitly. for instance: +JSDocの`@augments`を使って明示的に型を指定します。例えば: ```js import { Component } from "react"; @@ -272,32 +272,32 @@ import { Component } from "react"; */ class MyComponent extends Component { render() { - this.props.b; // Error: b does not exist on {a:number} + this.props.b; // エラー: b は {a:number} に存在しません } } ``` -### In JSDoc references +### JSDocリファレンスにおいて -An unspecified type argument in JSDoc defaults to any: +JSDocで指定されていない型引数のデフォルトはanyです: ```js twoslash /** @type{Array} */ var x = []; x.push(1); // OK -x.push("string"); // OK, x is of type Array +x.push("string"); // OK、xはArray型です /** @type{Array.} */ var y = []; y.push(1); // OK -y.push("string"); // Error, string is not assignable to number +y.push("string"); // エラー、stringはnumberに代入できません ``` -### In function calls +### 関数呼び出しにおいて -A call to a generic function uses the arguments to infer the type parameters. Sometimes this process fails to infer any types, mainly because of lack of inference sources; in these cases, the type parameters will default to `any`. For example: +ジェネリクス関数の呼び出しでは、引数から型パラメータを推論します。この処理では、主に推論の根拠がないために型の推論に失敗することが時たまあります。そのような場合、型パラメータはデフォルトで`any`となります。例えば: ```js var p = new Promise((resolve, reject) => { @@ -307,4 +307,4 @@ var p = new Promise((resolve, reject) => { p; // Promise; ``` -To learn all of the features available in JSDoc, see [the reference](/docs/handbook/jsdoc-supported-types.html). +JSDocで利用可能なすべての機能を知りたい場合は、[リファレンス](/docs/handbook/jsdoc-supported-types.html)を参照してください。 From c0125d7abdde27f58271678d29aa113fd2ae6576 Mon Sep 17 00:00:00 2001 From: uraway Date: Mon, 18 Jan 2021 21:32:58 +0900 Subject: [PATCH 3/4] Apply suggestions from code review Co-authored-by: Daiki Ihara --- .../ja/javascript/Creating DTS files From JS.md | 14 +++++++------- .../copy/ja/javascript/Intro to JS with TS.md | 4 ++-- .../copy/ja/javascript/JSDoc Reference.md | 12 ++++++------ .../javascript/Type Checking JavaScript Files.md | 6 +++--- 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md index 205098629edf..f72af7d2909a 100644 --- a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md +++ b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md @@ -9,7 +9,7 @@ translatable: true [TypeScript 3.7](/docs/handbook/release-notes/typescript-3-7.html#--declaration-and---allowjs)では、 TypeScriptに、JSDoc構文を使ったJavaScriptから.d.tsファイルを生成するためのサポートが導入されました。 -この仕組みは、プロジェクトをTypeScriptに移行することなく、TypeScriptが備わったエディタの経験を自分のものにできるということを意味します。 +この仕組みは、プロジェクトをTypeScriptに移行することなく、TypeScriptが備わったエディタの体験を自分のものにできるということを意味します。 TypeScriptはほとんどのJSDocタグをサポートしています。リファレンスは[こちら](/docs/handbook/type-checking-javascript-files.html#supported-jsdoc)。 ## .d.tsファイルを出力するようにプロジェクトを設定する @@ -19,7 +19,7 @@ TypeScriptはほとんどのJSDocタグをサポートしています。リフ - dev dependenciesにTypeScriptを追加する - TypeScriptを設定するための`tsconfig.json`を追加する - TypeScriptコンパイラを実行して、JSファイルに対応するd.tsファイルを生成する -- (オプション) package.jsonを編集して型を参照できるようにする +- (任意) package.jsonを編集して型を参照できるようにする ### TypeScriptを追加する @@ -36,7 +36,7 @@ TSConfigはコンパイラのフラグを設定し、対象のファイルを宣 include: ["src/**/*"], compilerOptions: { - // JSファイルは通常はソースファイルとしては無視されますが、 + // JSファイルは通常、ソースファイルとして無視されますが、 // ここではJSファイルを読み込むようにTypeScriptに指示します allowJs: true, // d.tsファイルを生成します @@ -53,7 +53,7 @@ TSConfigはコンパイラのフラグを設定し、対象のファイルを宣 ``` オプションについては、[tsconfigリファレンス](/reference)で詳しく知ることができます。 -TSConfigファイルを使用する代替手段としてCLIがあります。次は上記のTSConfigファイルと同じふるまいをするCLIコマンドです。 +TSConfigファイルを使用する代替手段としてCLIがあります。次は上記のTSConfigファイルの設定と同じふるまいをするCLIコマンドです。 ```sh npx typescript src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types @@ -62,12 +62,12 @@ npx typescript src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDi ## コンパイラを実行する 実行方法については[インストールページ](/download)を参照してください。 -プロジェクトの`.gitignore`に生成されたファイルがある場合は、確実にパッケージにそれらのファイルが含まれるようにしてください。 +プロジェクトの`.gitignore`にファイルが指定してある場合は、これらのファイルがパッケージに含まれていることを確認しましょう。 ## package.jsonを編集する -TypeScriptは、`package.json`の中でNodeのモジュール解決を再現し、.d.tsファイルを見つけるためのステップを追加します。 -大まかには、ノード解決はオプションである`"types"`フィールドをチェックし、次に`"main"`フィールド、そして最後にルートの`index.d.ts`を試します。 +TypeScriptは、.d.tsファイルを見つけるためのステップを追加し、`package.json`の中でNodeのモジュール解決を再現します。 +大まかには、モジュール解決はオプションである`"types"`フィールドをチェックし、次に`"main"`フィールド、そして最後にルートの`index.d.ts`を試します。 | Package.json | デフォルトの.d.tsの場所 | | :------------------------ | :----------------------------- | diff --git a/packages/documentation/copy/ja/javascript/Intro to JS with TS.md b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md index d14892a04331..9525a8945732 100644 --- a/packages/documentation/copy/ja/javascript/Intro to JS with TS.md +++ b/packages/documentation/copy/ja/javascript/Intro to JS with TS.md @@ -39,8 +39,8 @@ x = false; // OK?! ## `@ts-check` -前述のコードサンプルの最後の行はTypeScriptではエラーとなりますが、JSプロジェクトではデフォルトではエラーを発生させません。 -JavaScriptファイルでエラーを有効化するには、`.js`ファイルの最初の行に`// @ts-check`を追加して、TypeScriptのエラーを発生させるようにします。 +前述のコードサンプルの最後の行はTypeScriptではエラーとなりますが、JSプロジェクトのデフォルトではエラーを発生させません。 +JavaScriptファイルでエラーを有効化するには、`.js`ファイルの最初の行に`// @ts-check`を追加して、TypeScriptにエラーを発生させるようにします。 ```js twoslash // @ts-check diff --git a/packages/documentation/copy/ja/javascript/JSDoc Reference.md b/packages/documentation/copy/ja/javascript/JSDoc Reference.md index ef329ad58a51..a0f1c6d7201b 100644 --- a/packages/documentation/copy/ja/javascript/JSDoc Reference.md +++ b/packages/documentation/copy/ja/javascript/JSDoc Reference.md @@ -105,7 +105,7 @@ var stringToNumber; var arrayLike; ``` -前述の2つの型は、TypeScriptの型である`{ [x: string]: number }`と`{ [x: number]: any }`と等価です。コンパイラは両方の構文を理解します。 +前述の2つの型は、TypeScriptの型である`{ [x: string]: number }`および`{ [x: number]: any }`と等価です。コンパイラは両方の構文を理解します。 関数は、TypeScriptとClosureのどちらの構文を使っても指定することができます: @@ -223,7 +223,7 @@ var x = require("./accounts").userAccount; /** * @param {string} p1 - 文字列パラメータ * @param {string=} p2 - オプションのパラメータ(Closure構文) - * @param {string} [p3] - 別のオプションのパラメータ(JSDoc構文). + * @param {string} [p3] - オプションのパラメータ(JSDoc構文). * @param {string} [p4="test"] - デフォルト値を持つオプションのパラメータ * @return {string} 結果 */ @@ -587,7 +587,7 @@ var right; */ var wrong; /** - * 代わりにプロパティ名の前にクエスチョンマークを付けます: + * 代わりにプロパティ名の後ろにクエスチョンマークを付けます: * @type {{ a: string, b?: number }} */ var right; @@ -627,13 +627,13 @@ var normal; JSDocの型システムとは異なり、TypeScriptは型にnullが含まれるかどうか記すことしかできません。 明示的な非Nullable型はありません -- strictNullChecksが有効なら、`number`はNullableではありません。 -有効でないなら、`number`はNullableです。 +無効なら、`number`はNullableです。 ### サポートされていないタグ TypeScriptはサポートされていないJSDocタグを無視します。 -以下のタグは、サポートを目標としたオープンIssueがあります: +以下のタグは、サポートを目標とした進行中のIssueがあります: - `@const` ([issue #19672](https://github.com/Microsoft/TypeScript/issues/19672)) - `@inheritdoc` ([issue #23215](https://github.com/Microsoft/TypeScript/issues/23215)) @@ -667,7 +667,7 @@ const c = new Car(); console.log(c.identifier); ``` -- `@public`は常に暗示的であり、省略可能です。どこからでもプロパティにアクセスできることを意味します。 +- `@public`は常に暗黙的に宣言されており、省略可能です。どこからでもプロパティにアクセスできることを意味します。 - `@private`は、そのプロパティが含まれるクラス内でのみ使用可能であることを意味します。 - `@protected`は、そのプロパティが含まれるクラスと、そのクラスの派生クラス内で使用可能ですが、クラスのインスタンスからはアクセスできません。 diff --git a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md index 23e61ce1b51e..05ed3aca4f5e 100644 --- a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md +++ b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md @@ -77,7 +77,7 @@ C.prototype.method = function () { ## CommonJSモジュールがサポートされている -`.js`ファイルでは、TypeScriptはCommonJSモジュールフォーマットをサポートしています。 +`.js`ファイルでは、TypeScriptはCommonJSモジュール形式をサポートしています。 `exports`や`module.exports`への代入は、エクスポート宣言として認識されていますし、 同様に`require`関数の呼び出しも、モジュールインポートとして認識されます。例えば: @@ -230,7 +230,7 @@ sayHello(); ## 可変長引数のパラメータ宣言は、`arguments`の使い方から推測される -関数本体で`arguments`を参照すると、暗黙的に可変長引数パラメータ(例: `(...arg: any[]) => any`)を持っているとみなされます。JSDocの可変長引数構文を使って、引数の型を指定します。 +関数本体で`arguments`を参照すると、暗黙的に可変長引数パラメータ(つまり: `(...arg: any[]) => any`)を持っているとみなされます。JSDocの可変長引数構文を使って、引数の型を指定します。 ```js twoslash /** @param {...number} args */ @@ -250,7 +250,7 @@ Javascriptにはジェネリクス型のパラメータを指定するための ### extends句において 例えば、`React.Component`は、`Props`と`State`の2つの型パラメータを持つように定義されています。 -`.js`ファイルでは、extends句でこれらを指定する正当な方法はありません。型引数はデフォルトで`any`となります: +`.js`ファイルでは、extends句でこれらを指定する正しい方法はありません。型引数はデフォルトで`any`となります: ```js import { Component } from "react"; From 87cefc696233356060f56009fc4d7e66115cd267 Mon Sep 17 00:00:00 2001 From: Masato Urai Date: Mon, 18 Jan 2021 21:58:04 +0900 Subject: [PATCH 4/4] =?UTF-8?q?=E3=82=AA=E3=83=97=E3=82=B7=E3=83=A7?= =?UTF-8?q?=E3=83=B3=20=E2=86=92=20=E4=BB=BB=E6=84=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../javascript/Creating DTS files From JS.md | 2 +- .../copy/ja/javascript/JSDoc Reference.md | 20 +++++++++---------- .../Type Checking JavaScript Files.md | 10 +++++----- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md index f72af7d2909a..e5ccdbe82660 100644 --- a/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md +++ b/packages/documentation/copy/ja/javascript/Creating DTS files From JS.md @@ -67,7 +67,7 @@ npx typescript src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDi ## package.jsonを編集する TypeScriptは、.d.tsファイルを見つけるためのステップを追加し、`package.json`の中でNodeのモジュール解決を再現します。 -大まかには、モジュール解決はオプションである`"types"`フィールドをチェックし、次に`"main"`フィールド、そして最後にルートの`index.d.ts`を試します。 +大まかには、モジュール解決は任意のフィールドである`"types"`フィールドをチェックし、次に`"main"`フィールド、そして最後にルートの`index.d.ts`を試します。 | Package.json | デフォルトの.d.tsの場所 | | :------------------------ | :----------------------------- | diff --git a/packages/documentation/copy/ja/javascript/JSDoc Reference.md b/packages/documentation/copy/ja/javascript/JSDoc Reference.md index a0f1c6d7201b..b03b01cd6d2b 100644 --- a/packages/documentation/copy/ja/javascript/JSDoc Reference.md +++ b/packages/documentation/copy/ja/javascript/JSDoc Reference.md @@ -63,7 +63,7 @@ element.dataset.myData = ""; var sb; ``` -Union型の場合は、丸括弧はオプションであることに注意してください。 +Union型の場合は、丸括弧は任意であることに注意してください。 ```js twoslash /** @@ -216,15 +216,15 @@ var x = require("./accounts").userAccount; ## `@param`と`@returns` `@param`は`@type`と同じ型の構文を使用しますが、パラメータ名を追加します。 -また、パラメータ名を角括弧で囲むことで、パラメータをオプションとして宣言することもできます: +また、パラメータ名を角括弧で囲むことで、パラメータを任意のものとして宣言することもできます: ```js twoslash // パラメータは様々な構文形式で宣言することができます /** * @param {string} p1 - 文字列パラメータ - * @param {string=} p2 - オプションのパラメータ(Closure構文) - * @param {string} [p3] - オプションのパラメータ(JSDoc構文). - * @param {string} [p4="test"] - デフォルト値を持つオプションのパラメータ + * @param {string=} p2 - 任意のパラメータ(Closure構文) + * @param {string} [p3] - 任意のパラメータ(JSDoc構文). + * @param {string} [p4="test"] - デフォルト値を持つ任意のパラメータ * @return {string} 結果 */ function stringsStringStrings(p1, p2, p3, p4) { @@ -256,9 +256,9 @@ function ab() {} * @typedef {Object} SpecialType - 'SpecialType'という名前の新しい型を作成 * @property {string} prop1 - SpecialTypeの文字列プロパティ * @property {number} prop2 - SpecialTypeの数値プロパティ - * @property {number=} prop3 - SpecialTypeのオプションの数値プロパティ - * @prop {number} [prop4] - SpecialTypeのオプションの数値プロパティ - * @prop {number} [prop5=42] - SpecialTypeのデフォルト値を持つオプションの数値プロパティ + * @property {number=} prop3 - SpecialTypeの任意の数値プロパティ + * @prop {number} [prop4] - SpecialTypeの任意の数値プロパティ + * @prop {number} [prop5=42] - SpecialTypeのデフォルト値を持つ任意の数値プロパティ */ /** @type {SpecialType} */ @@ -273,7 +273,7 @@ specialTypeObject.prop3; * @typedef {object} SpecialType1 - 'SpecialType'という名前の新しい型を作成 * @property {string} prop1 - SpecialTypeの文字列プロパティ * @property {number} prop2 - SpecialTypeの数値プロパティ - * @property {number=} prop3 - SpecialTypeのオプションの数値プロパティ + * @property {number=} prop3 - SpecialTypeの任意の数値プロパティ */ /** @type {SpecialType1} */ @@ -579,7 +579,7 @@ var wrong; var right; ``` -オブジェクトリテラル型のプロパティ型の後ろに等号をつけても、オプションのプロパティにはなりません: +オブジェクトリテラル型のプロパティ型の後ろに等号をつけても、任意のプロパティにはなりません: ```js twoslash /** diff --git a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md index 05ed3aca4f5e..112f41e5a16d 100644 --- a/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md +++ b/packages/documentation/copy/ja/javascript/Type Checking JavaScript Files.md @@ -14,7 +14,7 @@ ES2015には、クラスのプロパティを宣言する手段がありませ `.js`ファイルでは、コンパイラはクラス本体のプロパティの代入からプロパティを推測します。 コンストラクタで型が定義されていない場合や、コンストラクタでの型がundefinedまたはnullである場合を除いて、プロパティの型はコンストラクタ内で与えられた型になります。 プロパティの型がコンストラクタ内で与えられない場合、プロパティの型は、プロパティの代入式におけるすべての右辺の値の型によるUnion型となります。 -メソッドやgetter、setter内で定義されたプロパティはオプションとみなされるのに対して、コンストラクタで定義されたプロパティは常に存在するものとみなされます。 +メソッドやgetter、setter内で定義されたプロパティは任意とみなされるのに対して、コンストラクタで定義されたプロパティは常に存在するものとみなされます。 ```js twoslash // @checkJs @@ -189,9 +189,9 @@ foo.l.push(foo.i); foo.l.push("end"); ``` -## 関数のパラメータはデフォルトではオプションである +## 関数のパラメータはデフォルトでは任意である -ES2015以前のJavascriptでは、パラメータがオプションかどうかを指定する方法がないため、`.js`ファイルの関数パラメータはすべてオプションとみなされます。 +ES2015以前のJavascriptでは、パラメータが任意かどうかを指定する方法がないため、`.js`ファイルの関数パラメータはすべて任意とみなされます。 宣言されたパラメータ数よりも少ない引数で、関数を呼び出すことが可能です。 宣言された数より、引数の数が多い関数を呼び出すとエラーになるので注意が必要です。 @@ -206,13 +206,13 @@ function bar(a, b) { console.log(a + " " + b); } -bar(1); // OK、二番目の引数はオプションとみなされます +bar(1); // OK、二番目の引数は任意とみなされます bar(1, 2); bar(1, 2, 3); // エラー、引数が多すぎます ``` JSDocの注釈付き関数はこの規則から除外されます。 -オプションであることを表すには、JSDocのオプションパラメータ構文(`[` `]`)を使用します。例えば: +任意であることを表すには、JSDocの任意パラメータ構文(`[` `]`)を使用します。例えば: ```js twoslash /**