Skip to content

JSDoc Reference 나머지 전체 번역 #120 #187

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 7 commits into from
Nov 11, 2020
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
70 changes: 35 additions & 35 deletions pages/jsdoc-reference.md
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ var win;
/** @type {PromiseLike<string>} */
var promisedString;

// You can specify an HTML Element with DOM properties
// DOM 프로퍼티를 사용하여 HTML 요소를 지정할 수 있습니다
/** @type {HTMLElement} */
var myElement = document.querySelector(selector);
element.dataset.myData = "";
Expand Down Expand Up @@ -439,27 +439,27 @@ var result = C(1);

> Note: 오류 메시지는 [a 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`를 사용하면 생성자 함수 `C`안에 `this`가 있는지 검사하므로, `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`의 타입을 지정할 수 있습니다:

```js
/**
* @this {HTMLElement}
* @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 클래스를 제네릭 기반 클래스로부터 상속(extend)하면, 매개변수가 어떤 타입이 되어야 하는지 지정할 곳이 없습니다. `@extends` 태그는 이러한 타입 매개변수를 위한 위치를 제공합니다:

```js
/**
Expand All @@ -471,11 +471,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
/** @enum {number} */
Expand All @@ -488,7 +488,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
/** @enum {function(number): number} */
Expand All @@ -501,65 +501,65 @@ const MathFuncs = {
MathFuncs.add1;
```

## More examples
## 추가 예제 (More examples)

```js
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
* JSX의 무상태 함수형 컴포넌트(SFC)에도 작동합니다
* @param {{a: string, b: number}} test - Some param
*/
var sfc = (test) => <div>{test.a.charAt(0)}</div>;

/**
* 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')
* @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
## 지원하지 않는다고 알려진 패턴 (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.
Value space 안의 객체를 타입으로 태그하는 것은 객체가 마치 생성자 함수처럼 타입을 생성하지 않는 이상 작동하지 않습니다.

```js
function aNormalFunction() {}
Expand All @@ -568,27 +568,27 @@ 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:
접미사(Postfix)는 선택적(Optional) 프로퍼티를 구체화하지 않는 객체 리터럴 타입의 프로퍼티 타입과 같습니다:

```js
/**
* @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:
`strictNullCheck`가 활성화 중인 경우에만 널러블(Nullable) 타입이 의미가 있습니다.

```js
/**
Expand All @@ -599,7 +599,7 @@ Nullable types only have meaning if `strictNullChecks` is on:
var nullable;
```

You can also use a union type:
유니언 타입을 사용해도 됩니다:

```js
/**
Expand All @@ -610,25 +610,25 @@ You can also use a union type:
var unionNullable;
```

Non-nullable types have no meaning and are treated just as their original type:
널러블 타입이 아닌 경우에는 아무 의미가 없으며 원래 타입으로 취급합니다:

```js
/**
* @type {!number}
* Just has type number
* 타입 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을 포함하거나 하지 않는다 표시할 수 있습니다.
널러블은 명확하게 구분되지 않습니다 -- 만약 strictNullChecks가 활성화 중이라면, `number`는 널러블하지 않습니다.
반대의 경우, `number`는 널러블합니다.

### Unsupported tags
### 지원하지 않는 태그 (Unsupported tags)

TypeScript ignores any unsupported JSDoc tags.
TypeScript는 지원하지 않는 JSDoc 태그를 무시합니다.

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))
Expand Down