设置函数参数的类型？

Question

有没有办法让 javascript 函数知道某个参数属于某种类型？

能够做这样的事情就完美了：

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

谢谢！

更新：如果我希望 myDate 被视为日期（以便在其上调用日期函数），那么答案是响亮的“否”，我必须强制转换将它作为函数内部的日期还是为其设置一个 Date 类型的新变量？

Answer 1

不，JavaScript 不是静态类型语言。有时您可能需要手动检查函数体中的参数类型。

Answer 2

不是在 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

Answer 3

虽然您无法告知 JavaScript语言关于类型的信息，但您可以告知您的 IDE 有关它们的信息，因此您可以获得更有用的自动完成功能。

这里有两种方法可以做到这一点：

1. 使用JSDoc，一个用于在 cmets 中记录 JavaScript 代码的系统。特别是，您需要@param directive:

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

   您也可以使用 JSDoc 到 define custom types 并在 @param 指令中指定它们，但请注意 JSDoc 不会进行任何类型检查；它只是一个文档工具。要检查 JSDoc 中定义的类型，请查看 TypeScript，它可以是 parse JSDoc tags。

2. 通过在 a
   /* comment */: 中的参数之前指定类型来使用类型提示：

   这是一种相当普遍的技术，例如使用by ReactJS。对于传递给第三方库的回调参数非常方便。

打字稿

对于实际的类型检查，最接近的解决方案是使用 TypeScript，它是 JavaScript 的 (mostly) 超集。这是TypeScript in 5 minutes。

Answer 4

查看来自 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

这里是how to run it。

Answer 5

您可以在您的函数中使用包装器来实现一个自动处理类型检查的系统。

通过这种方法，您可以构建一个完整的declarative type check system，它将为您管理类型检查。 如果您有兴趣更深入地了解这个概念，请查看Functyped library

以下实现以一种简单但可操作的方式说明了主要思想：

/*
 * 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

Answer 6

编辑：七年后，这个答案仍然偶尔得到支持。如果您正在寻找运行时检查，那很好，但我现在建议使用 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

Answer 7

不，相反，您需要根据自己的需要执行以下操作：

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

Answer 8

TypeScript 是目前最好的解决方案之一。

TypeScript 通过向语言添加类型来扩展 JavaScript。

https://www.typescriptlang.org/

Answer 9

ArgueJS 可以轻松完成：

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

Answer 10

说明

我不确定我的回答是否是对原始问题的直接回答，但我想很多人来这里只是为了找到一种方法来告诉他们的 IDE 理解类型，我'会分享我的发现。

如果您想告诉 VSCode 了解您的类型，请执行以下操作。请注意js runtime 和NodeJS 根本不关心这些类型。

解决方案

1- 创建一个以.d.ts 结尾的文件：例如：index.d.ts。您可以在另一个文件夹中创建此文件。例如：types/index.d.ts
2-假设我们想要一个名为view的函数。将这些行添加到index.d.ts:

/**
 * Use express res.render function to render view file inside layout file.
 *
 * @param {string} view The path of the view file, relative to view root dir.
 * @param {object} options The options to send to view file for ejs to use when rendering.
 * @returns {Express.Response.render} .
 */
view(view: string, options?: object): Express.Response.render;

3- 在项目的根目录中创建一个jsconfig.json 文件。 （似乎只需创建这个文件就足以让 VSCode 搜索您的类型）。

多一点

现在假设我们想将此类型添加到另一个库类型中。 （根据我自己的情况）。我们可以使用一些ts 关键字。只要 VSCode 理解ts，我们就没有问题。
例如，如果您想将这个 view 函数添加到来自 expressjs 的响应中，请将 index.d.ts 文件更改如下：

export declare global {
  namespace Express {
    interface Response {
      /**
       * Use express res.render function to render view file inside layout file.
       *
       * @param {string} view The path of the view file, relative to view root dir.
       * @param {object} options The options to send to view file for ejs to use when rendering.
       * @returns {Express.Response.render} .
       */
      view(view: string, options?: object): Express.Response.render;
    }
  }
}

结果

Answer 11

使用 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');
}

Answer 12

也许是这样的辅助函数。但如果你发现自己经常使用这样的语法，你可能应该改用 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
}

Answer 13

我也一直在考虑这个问题。在 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;
}

无论返回的实际值是什么类型，调用函数之前的 Number 都会返回 Number 类型，如第二次调用中 typeof rc = number 但值为 NaN 的情况

上面的console.log是：

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

Answer 14

我假设您允许 IDE 帮助您；那么下面的答案可能会对你有所帮助。

IDE：jetbrains/Golang ^{如果你的 IDE 不是这个也没关系。我相信所有支持 JSDoc 的 IDE 都能满足你的大部分要求。}

它可以很好地显示JSDoc。

演示

我的/pkg/encoding/base64.js

/**
 * Convert string to the base64 format.
 *
 * @param str {string} Input string
 * @returns {string} some message about return...
 * @example
 *  - btoa(toBinary("☸☹☺☻☼☾☿"))
 *  - Str2base64("☸☹☺☻☼☾☿")
 * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/btoa#unicode_strings
 */
export function Str2base64(str) {
  return btoa(toBinary(str))
}

test.js

import * as base64 from "../pkg/encoding/base64"
const filenameB64 = base64.Str2base64("test")

有用的 JSDoc 文档

• JSDoc Block Tags
  • 显示@returns、@param、@type的用法...

其他链接

• jetbrains/JSDoc comments