official - typescript undefined

¿Compatible con Typescript? ¿operador?(Y, ¿cómo se llama?)

Question

¿Tiene Typescript actualmente (o hay planes para) que admita el operador de navegación segura de ?.

es decir:

var thing = foo?.bar
// same as:
var thing = (foo) ? foo.bar : null;

Además, ¿hay un nombre más común para este operador (es difícil de buscar en Google).

Answer 1

¿No es tan lindo como un simple?, Pero funciona:

var thing = foo && foo.bar || null;

Puede usar todos los y && que desee:

var thing = foo && foo.bar && foo.bar.check && foo.bar.check.x || null;

Answer 2

Como se ha respondido antes, actualmente todavía se está considerando, pero ya github.com/Microsoft/TypeScript/issues/16 unos años github.com/Microsoft/TypeScript/issues/16 .

Sobre la base de las respuestas existentes, esta es la versión manual más concisa que puedo pensar:

jsfiddle

function val<T>(valueSupplier: () => T): T {
  try { return valueSupplier(); } catch (err) { return undefined; }
}

let obj1: { a?: { b?: string }} = { a: { b: ''c'' } };
console.log(val(() => obj1.a.b)); // ''c''

obj1 = { a: {} };
console.log(val(() => obj1.a.b)); // undefined
console.log(val(() => obj1.a.b) || ''Nothing''); // ''Nothing''

obj1 = {};
console.log(val(() => obj1.a.b) || ''Nothing''); // ''Nothing''

obj1 = null;
console.log(val(() => obj1.a.b) || ''Nothing''); // ''Nothing''

Simplemente falla silenciosamente cuando faltan errores de propiedad. Se recurre a la sintaxis estándar para determinar el valor predeterminado, que también se puede omitir por completo.

Aunque esto funciona para casos simples, si necesita elementos más complejos, como llamar a una función y luego acceder a una propiedad en el resultado, también se tragarán otros errores. Mal diseño.

En el caso anterior, una versión optimizada de la otra respuesta publicada aquí es la mejor opción:

jsfiddle

function o<T>(obj?: T, def: T = {} as T): T {
    return obj || def;
}

let obj1: { a?: { b?: string }} = { a: { b: ''c'' } };
console.log(o(o(o(obj1).a)).b); // ''c''

obj1 = { a: {} };
console.log(o(o(o(obj1).a)).b); // undefined
console.log(o(o(o(obj1).a)).b || ''Nothing''); // ''Nothing''

obj1 = {};
console.log(o(o(o(obj1).a)).b || ''Nothing''); // ''Nothing''

obj1 = null;
console.log(o(o(o(obj1).a)).b || ''Nothing''); // ''Nothing''

Un ejemplo más complejo:

o(foo(), []).map((n) => n.id)

También puedes ir por el otro lado y usar algo como Lodash '' _.get() . Es conciso, pero el compilador no podrá juzgar la validez de las propiedades utilizadas:

console.log(_.get(obj1, ''a.b.c''));

Answer 3

Creamos este método util mientras trabajamos en Phonetradr, que puede proporcionarle acceso de tipo seguro a propiedades profundas con Typescript:

/**
 * Type-safe access of deep property of an object
 *
 * @param obj                   Object to get deep property
 * @param unsafeDataOperation   Function that returns the deep property
 * @param valueIfFail           Value to return in case if there is no such property
 */
export function getInSafe<O,T>(obj: O, unsafeDataOperation: (x: O) => T, valueIfFail?: any) : T {
    try {
        return unsafeDataOperation(obj)
    } catch (error) {
        return valueIfFail;
    }
}

//Example usage:
getInSafe(sellTicket, x => x.phoneDetails.imeiNumber, '''');

//Example from above
getInSafe(foo, x => x.bar.check, null);

Answer 4

Esto se define en la especificación de encadenamiento opcional de ECMAScript, por lo que probablemente deberíamos referirnos al encadenamiento opcional cuando discutimos esto. Probable implementación:

const result = a?.b?.c;

En resumen, el equipo de TypeScript está esperando que la especificación ECMAScript se endurezca, por lo que su implementación puede ser continua en el futuro. Si implementaran algo ahora, terminarían necesitando grandes cambios si ECMAScript redefine su especificación.

Ver especificación de encadenamiento opcional

Donde algo nunca va a ser un JavaScript estándar, el equipo de TypeScript puede implementarlo como lo considere oportuno, pero para futuras incorporaciones de ECMAScript, quieren preservar la semántica incluso si otorgan acceso temprano, como lo han hecho para tantas otras características.

Cortes cortos

De modo que todos los operadores funky de JavaScripts están disponibles, incluidas las conversiones de tipo, como ...

var n: number = +myString; // convert to number
var b: bool = !!myString; // convert to bool

Solución manual

Pero volvamos a la pregunta. Tengo un obtuso ejemplo de cómo puedes hacer algo similar en JavaScript (y, por lo tanto, en TypeScript), aunque definitivamente no estoy sugiriendo que sea tan elegante como la función que realmente buscas.

(foo||{}).bar;

Entonces, si foo undefined está undefined el resultado undefined está undefined y si foo está definido y tiene una propiedad llamada bar que tiene un valor, el resultado es ese valor.

Pongo un ejemplo en JSFiddle .

Esto parece bastante incompleto para ejemplos más largos.

var postCode = ((person||{}).address||{}).postcode;

Función de cadena

Si está desesperado por una versión más corta mientras la especificación aún está en el aire, utilizo este método en algunos casos. Evalúa la expresión y devuelve un valor predeterminado si la cadena no puede ser satisfecha o termina nula / indefinida (tenga en cuenta que != Es importante aquí, no queremos usar !== ya que queremos un poco de malabarismo positivo aquí )

function chain<T>(exp: () => T, d: T) {
    try {
        let val = exp();
        if (val != null) {
            return val;
        }
    } catch { }
    return d;
}

let obj1: { a?: { b?: string }} = {
    a: {
        b: ''c''
    }
};

// ''c''
console.log(chain(() => obj1.a.b, ''Nothing''));

obj1 = {
    a: {}
};

// ''Nothing''
console.log(chain(() => obj1.a.b, ''Nothing''));

obj1 = {};

// ''Nothing''
console.log(chain(() => obj1.a.b, ''Nothing''));

obj1 = null;

// ''Nothing''
console.log(chain(() => obj1.a.b, ''Nothing''));

Answer 5

Hay una solicitud de función abierta para esto en github donde puede expresar su opinión / deseo: github.com/Microsoft/TypeScript/issues/16

Answer 6

No puedo encontrar ninguna referencia a eso en absoluto en la especificación del lenguaje TypeScript .

En lo que respecta a cómo llamar a este operador en CoffeeScript, se lo denomina operador existencial (específicamente, la "variante de acceso" del operador existencial).

De la documentación de CoffeeScript sobre Operadores :

La variante de acceso del operador existencial ?. se puede usar para absorber referencias nulas en una cadena de propiedades. Úselo en lugar del acceso de punto . en los casos en que el valor base puede ser nulo o indefinido .

Entonces, la variante accesoria del operador existencial parece ser la forma correcta de referirse a este operador; y TypeScript actualmente no parece ser compatible (aunque otros han expresado su deseo de esta funcionalidad ).

Answer 7

Operador ?. no es compatible con TypeScript versión 2.0 .

Entonces uso la siguiente función:

export function o<T>(someObject: T, defaultValue: T = {} as T) : T {
    if (typeof someObject === ''undefined'' || someObject === null)
        return defaultValue;
    else
        return someObject;
}

el uso se ve así:

o(o(o(test).prop1).prop2

Además, puede establecer un valor predeterminado:

o(o(o(o(test).prop1).prop2, "none")

Funciona muy bien con IntelliSense en Visual Studio.

Answer 8

Editar: He actualizado la respuesta gracias al comentario de fracz.

!. lanzó TypeScript 2.0 !. No es lo mismo que ?. (Safe Navigator en C #)

Vea esta respuesta para más detalles:

https://.com/a/38875179/1057052

Esto solo le indicará al compilador que el valor no es nulo ni indefinido. Esto no verificará si el valor es nulo o indefinido.

Operador de afirmación no nulo TypeScript

// Compiled with --strictNullChecks
function validateEntity(e?: Entity) {
    // Throw exception if e is null or invalid entity
}

function processEntity(e?: Entity) {
    validateEntity(e);
    let s = e!.name;  // Assert that e is non-null and access name
}