특정 매개 변수가 특정 유형임을 Javascript 함수에 알리는 방법이 있습니까?

이와 같은 것을 할 수 있다면 완벽 할 것입니다.

function myFunction(Date myDate, String myString)
{
    //do stuff
}

감사합니다!

업데이트 : 대답이 울리는 "아니오"이기 때문에 myDate(날짜 함수를 호출하기 위해) 날짜로 취급하려면 함수 내에서 날짜로 캐스팅하거나 새 변수를 설정해야합니다. 날짜를 입력 하시겠습니까?

아니요, JavaScript는 정적으로 유형이 지정된 언어가 아닙니다. 때로는 함수 본문에서 매개 변수 유형을 수동으로 확인해야 할 수도 있습니다.

자바 스크립트는 아니지만 Google Closure Compiler의 고급 모드를 사용하면 다음과 같이 할 수 있습니다.

/**
 * @param {Date} myDate The date
 * @param {string} myString The string
 */
function myFunction(myDate, myString)
{
    //do stuff
}

http://code.google.com/closure/compiler/docs/js-for-compiler.html을 참조하십시오 .

JavaScript 에 유형에 대한 언어를 알 수는 없지만 IDE에 유형에 대해 알릴 수 있으므로 훨씬 더 유용한 자동 완성을 얻을 수 있습니다.

이를 수행하는 두 가지 방법이 있습니다.

1. 주석에 JavaScript 코드를 문서화하는 시스템 인 JSDoc을 사용하십시오 . 특히 @param지시어 가 필요합니다 .

   /**
    * @param {Date} myDate - The date
    * @param {string} myString - The string
    */
   function myFunction(myDate, myString) {
     // ...
   }

   JSDoc을 사용하여 사용자 정의 유형 을 정의 하고 @param지시문에 유형 을 지정할 수도 있지만 JSDoc은 유형 검사를 수행하지 않습니다. 문서화 도구 일뿐입니다. 에 JSDoc,보기에 정의 된 유형을 확인하려면 타이프 라이터를 할 수있는, JSDoc 태그를 구문 분석 .

2. 에서 매개 변수 바로 앞에 유형을 지정하여 유형 힌트를 사용하십시오
   /* comment */.

   

   이것은 예를 들어 ReactJS 가 사용하는 꽤 광범위한 기술 입니다. 타사 라이브러리로 전달되는 콜백 매개 변수에 매우 편리합니다.

TypeScript

실제 유형 검사의 경우 가장 가까운 솔루션은 JavaScript 의 ( 대부분 ) 수퍼 셋 인 TypeScript를 사용하는 것 입니다. 여기 5 분 타이프 라이터를 .

Facebook 의 새로운 Flow 라이브러리 인 "JavaScript 프로그램에서 유형 오류를 찾기 위해 설계된 정적 유형 검사기"를 확인하십시오.

정의:

/* @flow */
function foo(x: string, y: number): string {
  return x.length * y;
}
foo('Hello', 42);

타입 검사 :

$> flow
hello.js:3:10,21: number
This type is incompatible with
  hello.js:2:37,42: string

그리고 여기에 그것을 실행하는 방법이 있습니다 .

아니요, 대신 필요에 따라 다음과 같은 작업을 수행해야합니다.

function myFunction(myDate, myString) {
  if(arguments.length > 1 && typeof(Date.parse(myDate)) == "number" && typeof(myString) == "string") {
    //Code here
  }
}

당신은 시스템을 구현할 수 있습니다 함수의 래퍼를 사용하여 형식 검사를 자동으로 처리 .

이 접근 방식 declarative type check system을 사용하면 유형 검사를 관리 할 수있는 완전한 빌드 할 수 있습니다 . 이 개념에 대해 더 자세히 살펴보고 싶다면 Functyped 라이브러리를

다음 구현은 단순하지만 작동 가능한 방식으로 주요 아이디어를 보여줍니다 .

/*
 * checkType() : Test the type of the value. If succeds return true, 
 * if fails, throw an Error
 */
function checkType(value,type, i){
  // perform the appropiate test to the passed 
  // value according to the provided type
  switch(type){
    case Boolean : 
      if(typeof value === 'boolean') return true;
      break;
    case String : 
      if(typeof value === 'string') return true;
      break;
    case Number : 
      if(typeof value === 'number') return true;
      break;
    default :
      throw new Error(`TypeError : Unknown type provided in argument ${i+1}`);
  }
  // test didn't succeed , throw error
  throw new Error(`TypeError : Expecting a ${type.name} in argument ${i+1}`);
}


/*
 * typedFunction() : Constructor that returns a wrapper
 * to handle each function call, performing automatic 
 * arguments type checking
 */
function typedFunction( parameterTypes, func ){
  // types definitions and function parameters 
  // count must match
  if(parameterTypes.length !== func.length) throw new Error(`Function has ${func.length} arguments, but type definition has ${parameterTypes.length}`);
  // return the wrapper...
  return function(...args){
    // provided arguments count must match types
    // definitions count
    if(parameterTypes.length !== args.length) throw new Error(`Function expects ${func.length} arguments, instead ${args.length} found.`);
    // iterate each argument value, and perform a
    // type check against it, using the type definitions
    // provided in the construction stage
    for(let i=0; i<args.length;i++) checkType( args[i], parameterTypes[i] , i)
    // if no error has been thrown, type check succeed
    // execute function!
    return func(...args);
  }
}

// Play time! 
// Declare a function that expects 2 Numbers
let myFunc = typedFunction( [ Number, Number ],  (a,b)=>{
  return a+b;
});

// call the function, with an invalid second argument
myFunc(123, '456')
// ERROR! Uncaught Error: TypeError : Expecting a Number in argument 2

편집 : 7 년이 지난 후에도이 대답은 여전히 ​​비정기적인 의견을 얻습니다. 런타임 검사를 찾고 있다면 괜찮지 만 Typescript 또는 Flow를 사용하여 컴파일 타임 유형 검사를 권장합니다. 자세한 내용은 위의 https://stackoverflow.com/a/31420719/610585를 참조 하십시오 .

원래 답변 :

언어에 내장되어 있지는 않지만 직접 쉽게 할 수 있습니다. Vibhu의 대답은 Javascript에서 일반적인 유형 검사 방법을 고려할 것입니다. 좀 더 일반화 된 것을 원한다면 다음과 같이 해보십시오.

typedFunction = function(paramsList, f){
    //optionally, ensure that typedFunction is being called properly  -- here's a start:
    if (!(paramsList instanceof Array)) throw Error('invalid argument: paramsList must be an array');

    //the type-checked function
    return function(){
        for(var i=0,p,arg;p=paramsList[i],arg=arguments[i],i<paramsList.length; i++){
            if (typeof p === 'string'){
                if (typeof arg !== p) throw new Error('expected type ' + p + ', got ' + typeof arg);
            }
            else { //function
                if (!(arg instanceof p)) throw new Error('expected type ' + String(p).replace(/\s*\{.*/, '') + ', got ' + typeof arg);
            }
        }
        //type checking passed; call the function itself
        return f.apply(this, arguments);
    }
}

//usage:
var ds = typedFunction([Date, 'string'], function(d, s){
    console.log(d.toDateString(), s.substr(0));
});

ds('notadate', 'test');
//Error: expected type function Date(), got string
ds();
//Error: expected type function Date(), got undefined
ds(new Date(), 42);
//Error: expected type string, got number
ds(new Date(), 'success');
//Fri Jun 14 2013 success

ArgueJS 로 쉽게 할 수 있습니다 .

function myFunction ()
{
  arguments = __({myDate: Date, myString: String});
  // do stuff
};

사용 typeof또는 instanceof:

const assert = require('assert');

function myFunction(Date myDate, String myString)
{
    assert( typeof(myString) === 'string',  'Error message about incorrect arg type');
    assert( myDate instanceof Date,         'Error message about incorrect arg type');
}

어쩌면 이런 도우미 기능 일 수도 있습니다. 그러나 이러한 구문을 정기적으로 사용하고 있다면 Typescript로 전환해야 할 것입니다.

function check(caller_args, ...types) {
    if(!types.every((type, index) => {
        if(typeof type === 'string')
            return typeof caller_args[index] === type
        return caller_args[index] instanceof type;
    })) throw Error("Illegal argument given");
}

function abc(name, id, bla) {
   check(arguments, "string", "number", MyClass)
   // code
}

나도 이것에 대해 생각하고있다. C 배경에서 다음과 같은 기능을 사용하여 함수 리턴 코드 유형과 매개 변수 유형을 시뮬레이션 할 수 있습니다.

function top_function() {
    var rc;
    console.log("1st call");
    rc = Number(test_function("number", 1, "string", "my string"));
    console.log("typeof rc: " + typeof rc + "   rc: " + rc);
    console.log("2nd call");
    rc = Number(test_function("number", "a", "string", "my string"));
    console.log("typeof rc: " + typeof rc + "   rc: " + rc);
}
function test_function(parm_type_1, parm_val_1, parm_type_2, parm_val_2) {
    if (typeof parm_val_1 !== parm_type_1) console.log("Parm 1 not correct type");
    if (typeof parm_val_2 !== parm_type_2) console.log("Parm 2 not correct type");
    return parm_val_1;
}

typeof rc = number이지만 값이 NaN 인 두 번째 호출에서 볼 수 있듯이 호출 함수 앞의 Number는 반환 된 실제 값의 유형에 관계없이 Number 유형을 반환합니다.

위의 console.log는 다음과 같습니다.

1st call
typeof rc: number   rc: 1
2nd call
Parm 1 not correct type
typeof rc: number   rc: NaN

TypeScript는 현재 최고의 솔루션 중 하나입니다

TypeScript는 언어에 유형을 추가하여 JavaScript를 확장합니다.

https://www.typescriptlang.org/