TypeScript güçlü bir şekilde yazıldığından, yalnızca if () {}denetlemek için kullanın nullve undefineddoğru ses gelmiyor.

TypeScript'in bunun için özel bir işlevi veya sözdizimi şekeri var mı?

Bir hokkabazlık-çek kullanarak, hem test edebilirsiniz nullve undefinedbir vuruşta:

if (x == null) {

Katı denetim kullanırsanız, bu yalnızca nulltanımlanmış değişkenler için doğru olur ve tanımlanmamış değişkenler için doğru olarak değerlendirilmez:

if (x === null) {

Bu örneği kullanarak bunu çeşitli değerlerle deneyebilirsiniz:

var a: number;
var b: number = null;

function check(x, name) {
    if (x == null) {
        console.log(name + ' == null');
    }

    if (x === null) {
        console.log(name + ' === null');
    }

    if (typeof x === 'undefined') {
        console.log(name + ' is undefined');
    }
}

check(a, 'a');
check(b, 'b');

Çıktı

"a == null"

"a tanımsız"

"b == null"

"b === null"

if( value ) {
}

için değerlendirecek trueeğer valuedeğildir:

• null
• undefined
• NaN
• boş dize ''
• 0
• false

daktilo javascript kurallarını içerir.

TypeScript bunun için özel bir işleve veya sözdizimi şekerine sahip mi?

TypeScript, JavaScript sürümünü tam olarak anlar something == null.

Typescript doğru hem ekarte edecek nullve undefinedbu tür kontroller ile.

Daha

https://basarat.gitbook.io/typescript/recap/null-undefined

Daktilo oyun alanında farklı testler yaptım:

http://www.typescriptlang.org/play/

let a;
let b = null;
let c = "";
var output = "";

if (a == null) output += "a is null or undefined\n";
if (b == null) output += "b is null or undefined\n";
if (c == null) output += "c is null or undefined\n";
if (a != null) output += "a is defined\n";
if (b != null) output += "b is defined\n";
if (c != null) output += "c is defined\n";
if (a) output += "a is defined (2nd method)\n";
if (b) output += "b is defined (2nd method)\n";
if (c) output += "c is defined (2nd method)\n";

console.log(output);

verir:

a is null or undefined
b is null or undefined
c is defined

yani:

• (a == null) 'ın null veya undefined olup olmadığını bilmek doğru olup olmadığını kontrol etme
• a'nın tanımlanıp tanımlanmadığını (a! = null) doğru olup olmadığını kontrol etme
• a'nın tanımlanıp tanımlanmadığını bilmek için (a) yanlış olup olmadığını kontrol etme

Bu cevabın bir güncellemeye ihtiyacı olduğunu düşünüyorum, eski cevabın düzenleme geçmişini kontrol edin.

Temel olarak, boş, tanımsız ve bildirilmemiş üç farklı durumunuz var, aşağıdaki snippet'e bakın.

// bad-file.ts
console.log(message)

Bir hata alırsınız, değişken messagetanımsızdır (aka belirtilmemiş), elbette, Typcript derleyicisi bunu yapmanıza izin vermemelidir, ancak GERÇEKTEN hiçbir şey sizi engelleyemez.

// evil-file.ts
// @ts-gnore
console.log(message)

Derleyici yukarıdaki kodu derlemekten mutluluk duyacaktır. Yani, tüm değişkenlerin bildirildiğinden eminseniz bunu yapabilirsiniz

if ( message != null ) {
    // do something with the message
}

Yukarıdaki kod kontrol eder nullve undefinedANCAK durumda messagedeğişken (güvenlik için) bildirilmeyen edilebilir, aşağıdaki kodu dikkate alabilir

if ( typeof(message) !== 'undefined' && message !== null ) {
    // message variable is more than safe to be used.
}

Not: Buradaki sipariş typeof(message) !== 'undefined' && message !== nullçok önemlidir, önce undefineddurumu kontrol etmeniz gerekir, aksi takdirde message != nullteşekkürler @Jaider.

In typescript 3.7 şu anda elimizde Opsiyonel zincirleme ve Nullish kaynaştırma kontrol etmek null adlı ve tanımsız aynı sürede, örnek:

let x = foo?.bar.baz();

bu kod foo'nun tanımlanıp tanımlanmadığını kontrol eder, aksi takdirde tanımsız olarak döner

eski yol :

if(foo != null && foo != undefined) {
   x = foo.bar.baz();
} 

bu:

let x = (foo === null || foo === undefined) ? undefined : foo.bar();

if (foo && foo.bar && foo.bar.baz) { // ... }

İsteğe bağlı zincirleme ile:

let x = foo?.bar();

if (foo?.bar?.baz) { // ... }

diğer bir yeni özellik de Nullish Coalescing , örnek:

let x = foo ?? bar(); // return foo if it's not null or undefined otherwise calculate bar

eski yol:

let x = (foo !== null && foo !== undefined) ?
foo :
bar();

Denemek isteyebilirsiniz

if(!!someValue)

ile !!.

açıklama

Birincisi !ifadenizi bir booleandeğere dönüştürecektir .

Sonra !someValueise trueeğer someValueolduğunu falsy ve falseeğer someValueolduğunu truthy . Bu kafa karıştırıcı olabilir.

Başka ekleyerek !, ifade şimdi trueise someValueise truthy ve falseeğer someValueolduğunu falsy yönetmek çok daha kolay olan.

Tartışma

Şimdi, neden if (!!someValue)benzer bir şey if (someValue)bana aynı sonucu verirse kendimi neden rahatsız ediyorum ?

Çünkü !!someValuekesinlikle boolean bir ifadedir, oysa someValuekesinlikle her şey olabilir. Bu tür bir ifade şimdi fonksiyonlar (ve Tanrı'ya ihtiyacımız var) yazmak gibi olacak:

isSomeValueDefined(): boolean {
  return !!someValue
}

onun yerine:

isSomeValueDefined(): boolean {
  if(someValue) {
    return true
  }
  return false
}

Umut ediyorum bu yardım eder.

Çünkü Typescript 2.x.xbunu aşağıdaki şekilde yapmalısınız ( tip koruyucuyu kullanarak ):

tl; Dr.

function isDefined<T>(value: T | undefined | null): value is T {
  return <T>value !== undefined && <T>value !== null;
}

Neden?

Bu şekilde isDefined()değişkenin türüne saygı duyulur ve aşağıdaki kod bu kontrolü dikkate alır.

Örnek 1 - temel kontrol:

function getFoo(foo: string): void { 
  //
}

function getBar(bar: string| undefined) {   
  getFoo(bar); //ERROR: "bar" can be undefined
  if (isDefined(bar)) {
    getFoo(bar); // Ok now, typescript knows that "bar' is defined
  }
}

Örnek 2 - Türlere saygı:

function getFoo(foo: string): void { 
  //
}

function getBar(bar: number | undefined) {
  getFoo(bar); // ERROR: "number | undefined" is not assignable to "string"
  if (isDefined(bar)) {
    getFoo(bar); // ERROR: "number" is not assignable to "string", but it's ok - we know it's number
  }
}

if(data){}

bu demek oluyor ki

• boş
• Tanımsız
• yanlış
• ....

TypeScript kullanıyorsanız, derleyicinin çalışma zamanında denetlemek yerine null'ları ve tanımsızları (veya olasılığını) denetlemesine izin vermek daha iyi bir yaklaşımdır. (Çalışma zamanında kontrol etmek istiyorsanız, cevapların belirttiği gibi, sadece kullanın value == null).

strictNullChecksDerleyiciye olası boş veya tanımsız değerleri boğmasını bildirmek için derleme seçeneğini kullanın . Bu seçeneği ayarlamak ve sonra bir durum varsa do null adlı izin ve tanımsız istiyoruz, siz türünü tanımlayabilirsiniz Type | null | undefined.

Eğer geçmek istiyorsanız tslintayarlamadan strict-boolean-expressionsiçin allow-null-unionya allow-undefined-union, sen kullanımına ihtiyaç isNullOrUndefinedden nodes' utilmodülü veya kendi rulo:

// tslint:disable:no-null-keyword
export const isNullOrUndefined =
  <T>(obj: T | null | undefined): obj is null | undefined => {
    return typeof obj === "undefined" || obj === null;
  };
// tslint:enable:no-null-keyword

Tam sözdizimsel şeker değil, tslint kurallarınız sıkı olduğunda yararlıdır.

nullKontroller için daha hızlı ve daha kısa bir gösterim olabilir:

value == null ? "UNDEFINED" : value

Bu satır şuna eşdeğerdir:

if(value == null) {
       console.log("UNDEFINED")
} else {
    console.log(value)
}

Özellikle çok fazla nullçekiniz olduğunda hoş bir kısa gösterimdir.

Ben bu sorunu vardı ve bazı cevap işe yarıyor JSama TSburada değil nedeni.

//JS
let couldBeNullOrUndefined;
if(couldBeNullOrUndefined == null) {
  console.log('null OR undefined', couldBeNullOrUndefined);
} else {
  console.log('Has some value', couldBeNullOrUndefined);
}

JS'nin Türleri olmadığı için hepsi iyi

//TS
let couldBeNullOrUndefined?: string | null; // THIS NEEDS TO BE TYPED AS undefined || null || Type(string)

if(couldBeNullOrUndefined === null) { // TS should always use strict-check
  console.log('null OR undefined', couldBeNullOrUndefined);
} else {
  console.log('Has some value', couldBeNullOrUndefined);
}

TS değişken ile tanımlı olmasaydı nullbunun için kontrol çalıştığınızda | derleyici şikayet edecek.nulltslint

//tslint.json
...
"triple-equals":[true],
...

 let couldBeNullOrUndefined?: string; // to fix it add | null

 Types of property 'couldBeNullOrUndefined' are incompatible.
      Type 'string | null' is not assignable to type 'string | undefined'.
        Type 'null' is not assignable to type 'string | undefined'.

Bu konuya geçmek için geç kaldım, ancak bu JavaScript hackinin bir değerin tanımlanıp tanımlanmadığını kontrol etmede çok kullanışlı olduğunu düşünüyorum

 if(typeof(something) === 'undefined'){
   // Yes this is undefined
 }

Genellikle Fenton'un zaten tartıştığı gibi hokkabazlık kontrolünü yaparım . Daha okunabilir hale getirmek için, ramda'dan isNil'i kullanabilirsiniz .

import * as isNil from 'ramda/src/isNil';

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Ayrıntılı bir yol olarak, SADECE boş ve tanımsız değerleri karşılaştırmak istiyorsanız , referans için aşağıdaki örnek kodu kullanın:

const incomingValue : string = undefined;
const somethingToCompare : string = incomingValue; // If the line above is not declared, TypeScript will return an excepion

if (somethingToCompare == (undefined || null)) {
  console.log(`Incoming value is: ${somethingToCompare}`);
}

Eğer incomingValuebildirilmedi, typescript bir istisna dönmelidir. Bu beyan edilmiş ancak tanımlanmamışsa,console.log() "Gelen değer: tanımsız" değerini döndürür. Sıkı eşit işleç kullanmadığımızı unutmayın.

"Doğru" yol (ayrıntılar için diğer yanıtları kontrol edin), eğer incomingValuebir booleantür değilse , sadece değerinin doğru olup olmadığını değerlendirin, bu sabit / değişken tipine göre değerlendirilecektir. Bir truedize, = ''atama kullanılarak açıkça dize olarak tanımlanmalıdır . Değilse, olarak değerlendirilecektir false. Aynı durumu kullanarak bu durumu kontrol edelim:

const incomingValue : string = undefined;
const somethingToCompare0 : string = 'Trumpet';
const somethingToCompare1 : string = incomingValue;

if (somethingToCompare0) {
  console.log(`somethingToCompare0 is: ${somethingToCompare0}`); // Will return "somethingToCompare0 is: Trumpet"
}

// Now, we will evaluate the second constant
if (somethingToCompare1) {
  console.log(`somethingToCompare1 is: ${somethingToCompare1}`); // Launched if incomingValue is defined
} else {
  console.log(`somethingToCompare1 is: ${somethingToCompare1}`); // Launched if incomingValue is undefined. Will return "somethingToCompare1 is: undefined"
}

kullanabilirsiniz

if(x === undefined)

Herşey,

En çok oy alan cevap, bir nesne ile çalışıyorsanız gerçekten işe yaramaz. Bu durumda, bir özellik yoksa, denetim çalışmaz. Bizim durumumuzdaki sorun buydu: şu örneğe bakın:

var x =
{ name: "Homer", LastName: "Simpson" };

var y =
{ name: "Marge"} ;

var z =
{ name: "Bart" , LastName: undefined} ;

var a =
{ name: "Lisa" , LastName: ""} ;

var hasLastNameX = x.LastName != null;
var hasLastNameY = y.LastName != null;
var hasLastNameZ = z.LastName != null;
var hasLastNameA = a.LastName != null;



alert (hasLastNameX + ' ' + hasLastNameY + ' ' + hasLastNameZ + ' ' + hasLastNameA);

var hasLastNameXX = x.LastName !== null;
var hasLastNameYY = y.LastName !== null;
var hasLastNameZZ = z.LastName !== null;
var hasLastNameAA = a.LastName !== null;

alert (hasLastNameXX + ' ' + hasLastNameYY + ' ' + hasLastNameZZ + ' ' + hasLastNameAA);

Sonuç:

true , false, false , true (in case of !=)
true , true, true, true (in case of !==) => so in this sample not the correct answer

plunkr bağlantısı: https://plnkr.co/edit/BJpVHD95FhKlpHp1skUE

TypeScript, ES6 JavaScript'in yazılı üst kümesi olduğundan. Ve kahkaha bir javascript kütüphanesi.

Değer null veya undefined olup olmadığını kontrol etmek için lodash kullanımı kullanılarak yapılabilir _.isNil().

_.isNil(value)

Argümanlar

değer (*): Kontrol edilecek değer.

İadeler

(boolean) : Değer nullish ise true değerini, aksi takdirde false değerini döndürür.

Misal

_.isNil(null);
// => true

_.isNil(void 0);
// => true

_.isNil(NaN);
// => false

bağlantı

Lodash Dokümanları

Yerel depolama alanı kullanıyorsanız dikkatli olun, tanımsız değer yerine tanımsız dizeyle sonuçlanabilir:

localStorage.setItem('mykey',JSON.stringify(undefined));
localStorage.getItem('mykey') === "undefined"
true

İnsanlar bunu faydalı bulabilir: https://github.com/angular/components/blob/master/src/cdk/coercion/boolean-property.spec.ts

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/** Coerces a data-bound value (typically a string) to a boolean. */
export function coerceBooleanProperty(value: any): boolean {
  return value != null && `${value}` !== 'false';
}

import {coerceBooleanProperty} from './boolean-property';

describe('coerceBooleanProperty', () => {

  it('should coerce undefined to false', () => {
    expect(coerceBooleanProperty(undefined)).toBe(false);
  });

  it('should coerce null to false', () => {
    expect(coerceBooleanProperty(null)).toBe(false);
  });

  it('should coerce the empty string to true', () => {
    expect(coerceBooleanProperty('')).toBe(true);
  });

  it('should coerce zero to true', () => {
    expect(coerceBooleanProperty(0)).toBe(true);
  });

  it('should coerce the string "false" to false', () => {
    expect(coerceBooleanProperty('false')).toBe(false);
  });

  it('should coerce the boolean false to false', () => {
    expect(coerceBooleanProperty(false)).toBe(false);
  });

  it('should coerce the boolean true to true', () => {
    expect(coerceBooleanProperty(true)).toBe(true);
  });

  it('should coerce the string "true" to true', () => {
    expect(coerceBooleanProperty('true')).toBe(true);
  });

  it('should coerce an arbitrary string to true', () => {
    expect(coerceBooleanProperty('pink')).toBe(true);
  });

  it('should coerce an object to true', () => {
    expect(coerceBooleanProperty({})).toBe(true);
  });

  it('should coerce an array to true', () => {
    expect(coerceBooleanProperty([])).toBe(true);
  });
});

Her zaman böyle yazıyorum:

var foo:string;

if(!foo){
   foo="something";    
}

Bu iyi çalışır ve bence çok okunabilir.