How to Fix “Type 'null' Is Not Assignable to Type” in TypeScript

TypeScript 7.0, released on July 8, 2026, moved the compiler to a new native implementation, but Microsoft says the port preserves the type-checking semantics developers already relied on. That matters here because the familiar Type 'null' is not assignable to type ... error is still fundamentally about your data model: a value may be null, while the destination type says it may not be.

In other words, there is no new TypeScript 7-specific trick to learn. The right fix is still to decide whether null is valid data, guard against it when it is not yet safe to use, or provide a deliberate fallback. The official TypeScript 7.0 announcement explains the compiler transition, while the current strictNullChecks documentation continues to define null and undefined as distinct types when strict null checking is enabled.

Why TypeScript says “Type 'null' is not assignable to type”

The error appears when an expression can evaluate to null but the receiving type excludes null. A minimal example is:

let name: string = null;

With strictNullChecks enabled, string means a real string value. It does not silently include null. The compiler therefore rejects the assignment instead of letting a possible missing value flow into code that assumes string methods are safe.

Turning off strictNullChecks can make the diagnostic disappear, but it also removes an important class of checks. TypeScript's own configuration reference warns that ignoring null and undefined can lead to unexpected runtime errors. For most maintained applications, fixing the model or the control flow is safer than disabling the check.

Choose the fix based on what null means in your program

Before changing syntax, decide what the missing value represents. The most maintainable solution depends on that answer.

Fix 1: Include null in the type when null is legitimate

If a variable genuinely has a “not available yet” or “no value” state, model that state explicitly:

let name: string | null = null;

name = "Avery";

Αυτή δεν είναι μια λύση. Είναι μια ακριβής σύμβαση. Το μεσαίο όνομα ενός προφίλ, ένα προαιρετικό αποτέλεσμα βάσης δεδομένων ή ένα επιλεγμένο στοιχείο που ξεκινά κενό μπορεί εύλογα να είναι μηδενικό. Μόλις ο τύπος πει string | null, ο κώδικας κατάντη πρέπει να αποδείξει ότι η τιμή είναι μια συμβολοσειρά πριν χρησιμοποιήσει λειτουργίες μόνο με συμβολοσειρές.

Χρησιμοποιήστε αυτήν την προσέγγιση όταν οι καλούντες πρέπει να διακρίνουν την έννοια «δεν υπάρχει τιμή» από μια πραγματική τιμή. Μην προσθέτετε | nullαντανακλαστικά απλώς για να σιγήσετε τον μεταγλωττιστή. Κάτι τέτοιο ωθεί την απαίτηση χειρισμού προς τα έξω.

Επίλυση 2: Περιορίστε την τιμή πριν τη χρησιμοποιήσετε

Εάν μια τιμή null γίνει ασφαλής μετά από έναν έλεγχο, αφήστε την ανάλυση ροής ελέγχου του TypeScript να περιορίσει τον τύπο. Το επίσημο εγχειρίδιο περιορισμού δείχνει ότι έλεγχοι όπως value !== nullη αφαίρεση nullαπό τον τύπο μέσα στον guarded κλάδο.

function printLength(text: string | null) {
  if (text === null) {
    console.log("No text");
    return;
  }

  console.log(text.length);
}

Μετά την πρόωρη επιστροφή, textείναι γνωστό ότι υπάρχει ένα string. Αυτό το μοτίβο κλιμακώνεται καλά επειδή ο έλεγχος ασφαλείας παραμένει κοντά στο σημείο όπου η υπόθεση γίνεται αληθής.

Χρησιμοποιήστε έναν ακριβή μηδενικό έλεγχο όταν οι ψευδείς τιμές είναι έγκυρες

Μια συνθήκη όπως if (text)εξαιρεί επίσης τις κενές συμβολοσειρές επειδή ""είναι ψευδής. Εάν μια κενή συμβολοσειρά έχει νόημα, προτιμήστε text !== null. Εάν η τιμή μπορεί να είναι είτε nullείτε undefined, value != nullείναι ένας συνοπτικός έλεγχος JavaScript που εξαιρεί και τα δύο. Το TypeScript κατανοεί αυτόν τον περιορισμό όπως τεκμηριώνεται στο εγχειρίδιο.

Διόρθωση 3: Παρέχετε μια προεπιλογή με τον μηδενικό τελεστή συγχώνευσης

Εάν η επιχειρηματική σας λογική έχει μια πραγματική εφεδρική τιμή, μετατρέψτε σκόπιμα την τιμή null σε μια μη null τιμή:

const rawName: string | null = getDisplayName();
const displayName: string = rawName ?? "Guest";

Ο ??τελεστής χρησιμοποιεί την δεξιά τιμή μόνο όταν η αριστερή πλευρά είναι nullή undefined. Αυτό το καθιστά καλύτερο εργαλείο προεπιλεγμένων τιμών από ό,τι ||όταν τιμές όπως "", 0, ή falseείναι έγκυρες και θα πρέπει να διατηρηθούν.

Αυτή η λύση είναι ιδανική για ετικέτες, προεπιλογές διαμόρφωσης και τιμές μόνο για εμφάνιση. Είναι λιγότερο κατάλληλη όταν το πρόγραμμά σας πρέπει να γνωρίζει εάν μια τιμή έλειπε πραγματικά, επειδή η εφεδρική λύση συμπτύσσει σκόπιμα αυτήν τη διάκριση.

Επίλυση 4: Χρησιμοποιήστε τον μη μηδενικό τελεστή διεκδίκησης μόνο όταν έχετε ήδη εγγύηση

Το postfix !λέει στο TypeScript να χειριστεί μια τιμή ως μη null και μη απροσδιόριστη:

const element = document.getElementById("status");
element!.textContent = "Ready";

Αυτό μεταγλωττίζεται επειδή !αφαιρεί το τμήμα null για τον έλεγχο τύπου. Δεν προσθέτει έλεγχο χρόνου εκτέλεσης. Εάν το στοιχείο δεν υπάρχει, ο κώδικας μπορεί να αποτύχει όταν προσπαθήσει να αποκτήσει πρόσβαση στο textContent.

Χρησιμοποιήστε !μόνο όταν κάποια άλλη αμετάβλητη τιμή εγγυάται πραγματικά ότι η τιμή υπάρχει και ο μεταγλωττιστής δεν μπορεί να εκφράσει ή να συμπεράνει αυτήν την αμετάβλητη τιμή. Για αναζητήσεις DOM, δεδομένα αιτήματος, αναγνώσεις cache και είσοδο χρήστη, ένας πραγματικός έλεγχος είναι συνήθως πιο αξιόπιστος:

const element = document.getElementById("status");
if (element) {
  element.textContent = "Ready";
}

Μια καλή ερώτηση για την αναθεώρηση κώδικα είναι: «Τι επιβάλλει αυτήν την τιμή κατά τον χρόνο εκτέλεσης;» Εάν η απάντηση είναι απλώς «το περιμένουμε», ο ισχυρισμός πιθανότατα κρύβει ένα σφάλμα αντί να το διορθώνει.

Διόρθωση 5: Διόρθωση του τύπου συνάρτησης ή αντικειμένου στην πηγή

Μερικές φορές η τοποθεσία ανάθεσης είναι αθώα και το πραγματικό πρόβλημα είναι μια παραπλανητική σύμβαση. Ας υποθέσουμε ότι μια αναζήτηση επιστρέφει nullόταν δεν υπάρχει πελάτης:

type Customer = { id: string; name: string };

function findCustomer(id: string): Customer | null {
  // Return a customer when found; otherwise return null.
  return null;
}

Εάν η συνάρτηση πληκτρολογούνταν ως returning only Customer, οι καλούντες θα λάμβαναν την πληροφορία ότι η αποτυχία είναι αδύνατη, παρόλο που η υλοποίηση λέει το αντίθετο. Προτιμήστε να διορθώσετε τον τύπο επιστροφής και να αναγκάσετε τους καλούντες να χειριστούν την περίπτωση που λείπει.

Η ίδια αρχή ισχύει και για τις διεπαφές. Εάν ένα πεδίο API μπορεί να περιέχει ρητά JSON null, μοντελοποιήστε το ως field: string | null. Εάν μια ιδιότητα μπορεί να απουσιάζει, μια προαιρετική ιδιότητα όπως η field?: stringαντιπροσωπεύει την απουσία μέσω του undefined, όχι του σαφούς null. Εάν εμφανίζονται και οι δύο μορφές, το μοντέλο μπορεί να χρειάζεται field?: string | null.

Επίλυση 6: Χρήση NonNullable για επαναχρησιμοποιήσιμους μετασχηματισμούς τύπων

Το TypeScript περιλαμβάνει το καθολικό NonNullable<Type>βοηθητικό πρόγραμμα, το οποίο αφαιρεί τα nullκαι undefinedαπό έναν τύπο. Η επίσημη τεκμηρίωση των τύπων βοηθητικού προγράμματος το αναφέρει ως μετασχηματισμό τυπικού τύπου.

type MaybeName = string | null | undefined;
type Name = NonNullable<MaybeName>; // string

Αυτό είναι χρήσιμο κατά την εξαγωγή ενός τύπου για ένα επικυρωμένο επίπεδο, αλλά δεν επικυρώνει τιμές από μόνο του. Χρειάζεστε ακόμα τη ροή ελέγχου χρόνου εκτέλεσης για να αποδείξετε ότι η πραγματική τιμή δεν είναι null πριν την επιστρέψετε ή την περάσετε ως τον μη null τύπο.

Τι γίνεται με το «ως συμβολοσειρά»;

Μια διεκδίκηση τύπου όπως το value as stringμπορεί να καταστείλει το σφάλμα, αλλά έχει τον ίδιο βασικό περιορισμό με το !: αλλάζει αυτό που πιστεύει ο μεταγλωττιστής χωρίς να ελέγχει την τιμή χρόνου εκτέλεσης. Είναι κατάλληλο μόνο όταν έχετε εξωτερική γνώση που το TypeScript δεν μπορεί να συμπεράνει. Δεν θα πρέπει να είναι η προεπιλεγμένη απόκριση σε δεδομένα με δυνατότητα μηδενισμού.

const value: string | null = getValue();
const forced = value as string; // Compiles, but may still be null at runtime

Αν χρειάζεται να αποδείξετε ότι η τιμή είναι μια συμβολοσειρά, προτιμήστε την επικύρωση:

const value: string | null = getValue();
if (typeof value !== "string") {
  throw new Error("Expected a string");
}

const safeValue: string = value;

Μην «διορθώνετε» το πρόβλημα απενεργοποιώντας το strictNullChecks

Με strictNullChecksορισμένη σε false, το TypeScript αγνοεί σε μεγάλο βαθμό τα nullκαι undefinedστη δυνατότητα εκχώρησης. Αυτό μπορεί να κάνει τον παλαιότερο κώδικα ευκολότερο στη μεταγλώττιση, αλλά αφαιρεί επίσης τη δυνατότητα του μεταγλωττιστή να επισημαίνει πολλές διαδρομές τιμών που λείπουν πριν από το χρόνο εκτέλεσης. Η τρέχουσα τεκμηρίωση συμβατότητας τύπων , που ενημερώθηκε τον Σεπτέμβριο του 2026, εξακολουθεί να διακρίνει τη συμπεριφορά των μηδενικών τιμών ανάλογα με αυτήν την επιλογή.

Εάν μετεγκαθιστάτε ένα μεγάλο έργο παλαιού τύπου, η ενεργοποίηση αυστηρότερων ελέγχων ενδέχεται να απαιτεί σταδιακό καθαρισμό. Ακόμα και τότε, αντιμετωπίστε την απενεργοποίηση του ελέγχου null ως περιορισμό μετεγκατάστασης και όχι ως την προτιμώμενη τοπική διόρθωση για ένα μόνο σφάλμα.

Μια πρακτική ακολουθία εντοπισμού σφαλμάτων

1. Διαβάστε τον τύπο προορισμού. Αν λέει string, User, ή κάποιον άλλο συγκεκριμένο τύπο, ρωτήστε αν nullθα έπρεπε όντως να επιτρέπεται εκεί.
2. Εντοπίστε πού εισάγεται η τιμή null. Ελέγξτε τον τύπο επιστροφής της συνάρτησης, την ιδιότητα αντικειμένου, το αποτέλεσμα αναζήτησης, το μοντέλο βάσης δεδομένων/API, το ερώτημα DOM ή την αρχική κατάσταση.
3. Επιλέξτε τη σημασιολογική διόρθωση. Μοντελοποιήστε το null με μια ένωση, περιορίστε το, παρέχετε ένα εφεδρικό αντίγραφο ή διορθώστε τη σύμβαση πηγής.
4. Χρησιμοποιήστε ισχυρισμούς μόνο για πραγματικές αναλλοίωτες μεταβλητές. Ένας μη μηδενικός ισχυρισμός ή ένας ισχυρισμός τύπου θα πρέπει να τεκμηριώνει τη γνώση που πραγματικά κατέχετε, όχι να διαγράφει την αβεβαιότητα.
5. Εκτελέστε ξανά τον μεταγλωττιστή και δοκιμάστε τη μηδενική διαδρομή. Μια καθαρή δόμηση αποδεικνύει ότι η σχέση τύπου είναι αποδεκτή. Μια δοκιμή κατά τον χρόνο εκτέλεσης αποδεικνύει ότι η συμπεριφορά σας σχετικά με τις ελλείπουσες τιμές ταιριάζει στην πραγματικότητα με την απαίτηση του προϊόντος.

Συνηθισμένα παραδείγματα και η καλύτερη απάντηση

Μια αναζήτηση μπορεί να αποτύχει

const user = users.find(u => u.id === id);

Array.prototype.findμπορεί να επιστρέψει undefined, επομένως προστατέψτε το αποτέλεσμα ή παρέχετε ένα εφεδρικό αντίγραφο. Αυτή είναι η ίδια συλλογιστική με μια τιμή null, παρόλο που ο τύπος που λείπει είναι undefinedαντί για null.

Ένα πεδίο βάσης δεδομένων ή API επιστρέφει ρητά null

Διατηρήστε | nullτον τύπο ορίου, εάν αυτός είναι που στέλνει στην πραγματικότητα η εξωτερική σύμβαση. Στη συνέχεια, μετατρέψτε ή επικυρώστε στο όριο όπου η εφαρμογή σας απαιτεί μια πραγματική τιμή.

Μια μεταβλητή ξεκινάει κενή αλλά πρέπει να συμπληρωθεί αργότερα

Χρησιμοποιήστε μια ένωση με δυνατότητα μηδενισμού κατά τη φάση όπου η τιμή "μη έτοιμη" είναι έγκυρη ή αναδιαρθρώστε τον κώδικα έτσι ώστε η κατασκευή να απαιτεί την τιμή. Προτιμήστε τη δεύτερη προσέγγιση όταν ένα πλήρως αρχικοποιημένο αντικείμενο δεν πρέπει ποτέ να υπάρχει σε μερική κατάσταση.

Συμπέρασμα

Η ασφαλέστερη λύση για το σφάλμα "Ο τύπος 'null' δεν μπορεί να αντιστοιχιστεί σε τύπο" δεν είναι ένας μόνο τελεστής. Είναι η επιλογή ενός τύπου που αντικατοπτρίζει την πραγματικότητα και, στη συνέχεια, η προσαρμογή της ροής ελέγχου σε αυτόν τον τύπο. Χρησιμοποιήστε T | nullόταν η τιμή null είναι έγκυρη, ρητή μείωση όταν η τιμή πρέπει να ελεγχθεί, ??όταν υπάρχει πραγματική εφεδρική τιμή και !μόνο όταν υπάρχει εγγύηση χρόνου εκτέλεσης εκτός της προβολής του TypeScript.

Το TypeScript 7.0 αλλάζει την αρχιτεκτονική του μεταγλωττιστή, όχι αυτήν την αρχή σχεδίασης. Εάν ο κώδικάς σας λέει ότι μια τιμή δεν μπορεί να είναι null, κάντε αυτήν τη δήλωση αληθή κατά τον χρόνο εκτέλεσης καθώς και στο σύστημα τύπων.