Actualizar para mayor claridad. La sobrecarga de métodos a máquina de escribir es una característica útil en la medida en que le permite crear definiciones de tipos de bibliotecas existentes con una API que necesita ser representado.

Al escribir su propio código, sin embargo, bien puede ser capaz de evitar la sobrecarga cognitiva de sobrecargas utilizando parámetros opcionales o por defecto. Esta es la alternativa más legible a sobrecargas de método y también mantiene su API honesto como usted evitará la creación de sobrecargas mediante los pedidos poco intuitivo.

La ley general de mecanografiado sobrecarga es:

Si usted puede eliminar las firmas de sobrecarga y todas las pruebas pasan, no es necesario sobrecargas mecanografiado

Generalmente, usted puede lograr lo mismo con los parámetros opcionales, o por defecto - o con tipos de unión, o con un poco de orientación a objetos.

La pregunta real

La pregunta real pide una sobrecarga de:

someMethod(stringParameter: string): void {

someMethod(numberParameter: number, stringParameter: string): void {

Ahora incluso en lenguajes que soportan sobrecargas con implementaciones separadas (nota: sobrecargas mecanografiado comparten una sola aplicación) - programadores son consejos para proporcionar consistencia en el pedido. Esto haría que las firmas:

someMethod(stringParameter: string): void {

someMethod(stringParameter: string, numberParameter: number): void {

El stringParametersiempre se requiere, por lo que va en primer lugar. Se puede escribir esto como una sobrecarga de trabajo mecanografiado:

someMethod(stringParameter: string): void;
someMethod(stringParameter: string, numberParameter: number): void;
someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

Sin embargo, siguiendo la ley de sobrecargas mecanografiado, podemos eliminar las firmas de sobrecarga y todas nuestras pruebas todavía pasaremos.

someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

La pregunta real, en el orden real

Si se determinaron a persistir con el orden original, las sobrecargas serían:

someMethod(stringParameter: string): void;
someMethod(numberParameter: number, stringParameter: string): void;
someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Ahora que es una gran cantidad de ramificación de averiguar dónde poner los parámetros, pero que realmente querían preservar este orden si usted está leyendo esto ahora ... Pero espera, ¿qué ocurre si aplicamos la ley de sobrecargas mecanografiado?

someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Ya lo suficientemente ramificación

Por supuesto, dada la cantidad de comprobación de tipos que tenemos que hacer ... tal vez la mejor respuesta es simplemente tener dos métodos:

someMethod(stringParameter: string): void {
  this.someOtherMethod(0, stringParameter);
}

someOtherMethod(numberParameter: number, stringParameter: string): void {
  //...
}

Deseo. Quiero que esta característica también, pero mecanografiado necesidades para que funcione con JavaScript sin tipo que no tiene métodos sobrecargados. es decir, si su método sobrecargado se llama desde JavaScript entonces sólo puede obtener enviado a una implementación del método.

Hay \ sa pocas discusiones pertinentes en CodePlex. p.ej

https://typescript.codeplex.com/workitem/617

Todavía pienso mecanografiado debe generar toda la if'ing y la conmutación por lo que no tendría que hacerlo.

Javascript no tiene ningún concepto de sobrecarga. Letra de imprenta no es C # o Java.

Pero se puede poner en práctica la sobrecarga a máquina de escribir.

Leer este post http://www.gyanparkash.in/function-overloading-in-typescript/

¿Por qué no usar interfaz definida propiedad opcional como el argumento de la función ..

Para el caso en esta pregunta, utilizando una interfaz de línea definido con algunas propiedades opcionales sólo directamente podría hacer que el código como algo a continuación:

class TestClass {

    someMethod(arg: { stringParameter: string, numberParameter?: number }): void {
        let numberParameterMsg = "Variant #1:";
        if (arg.numberParameter) {
            numberParameterMsg = `Variant #2: numberParameter = ${arg.numberParameter},`;
        }
        alert(`${numberParameterMsg} stringParameter = ${arg.stringParameter}`);
    }
}

var testClass = new TestClass();
testClass.someMethod({ stringParameter: "string for v#1" });
testClass.someMethod({ numberParameter: 12345, stringParameter: "string for v#2" });

Debido a la sobrecarga proporcionada a máquina de escribir es, como se menciona en los comentarios de los demás, sólo una lista de diferentes firmas de función sin tener que apoyar los códigos de ejecución correspondientes al igual que otros lenguajes estáticos. Por lo que la aplicación todavía tiene que ser hecho en un solo cuerpo de la función, lo que hace que el uso de la sobrecarga de funciones a máquina de escribir no tan cómodo como tales idiomas que apoyan la función de sobrecarga real.

Sin embargo, todavía hay muchas materias nuevas y convenientes proporcionados a máquina que no está disponible en el lenguaje de programación legado, donde el apoyo de propiedad opcional en una interfaz anónimo es un enfoque para satisfacer la zona cómoda de la sobrecarga de funciones legado, creo.

class User{
   name : string;
   age : number;
   constructor(name:string,age:number){
    this.name = name;
    this.age = age;
    console.log("User " +this.name+ " Created")
}
getName(name:string = ""):string{
    if(name != ""){
        return name + " " +this.name;
    }else{
        return this.name;
    }
  }

}

Creo que esto debería funcionar