<center>![Unknown & Never in TypeScript](https://images.ecency.com/DQmdYjFdMYKc7zaV1BfqrekrkUqNUrEhCRRamEED7yqHu6M/001_understanding_typescript.jpg)</center>

<p>
    There are 2 other main types that are important to be familiar with. These types are not as common as other types, but they still have their uses. The first of these types is <code>unknown</code>. For example, suppose I have a variable like this:
</p>
<pre><code class="language-typescript">let userInput: unknown;</code></pre>
<p>
I've assumed here that we don't know what the user is going to enter in this field, so I've given it the type <code>unknown</code>. As it turns out, we can store any value in <code>unknown</code> without error:
</p>
<pre><code class="language-typescript">let userInput: unknown;
userInput = 5;
userInput = 'Max';</code></pre>
<p>
    If I run <code>tsc app.ts</code> now, typescript compiles my code without any errors. You may ask yourself what is the difference between <code>any</code> and <code>unknown</code>. Yes, these two types are very similar, but they have an interesting difference. Suppose we have another variable whose type is <code>string</code>:
</p>
<pre><code class="language-typescript">let userName: string;</code></pre>
<p>
If we assign such a variable to <code>userInput</code>, we will encounter an error:
</p>
<pre><code class="language-typescript">let userInput: unknown;
let userName: string;
userInput = 5;
userInput = 'Max';
userName = userInput;</code></pre>
<p>
    In the code above, Typescript immediately draws a red line under the last line of the code and gives us an error:
</p>

<center>![Type script error for type unknown](https://images.ecency.com/DQmTWN6FAzEnSQdHXfrTSe8EL5L88v6k5oNBG1agUJAshqk/01_unknown_to_string.png)</center>

<p>
    I think the reason for this error is clear to you. The <code>userName</code> variable requires a string value, but it is not clear whether <code>userInput</code> is a string or takes another value! The interesting thing is that if I set <code>userInput</code> to <code>any</code> I don't get any error:
</p>
<pre><code class="language-typescript">let userInput: any;
let userName: string;
userInput = 5;
userInput = 'Max';
userName = userInput;</code></pre>
<p>
    This code for typescript is completely correct! why Because <code>any</code> is the most flexible type in the Typescript language and disables all type checks. In other words, if you use <code>any</code> for a variable or parameter, you lose the ability to specify the type for it because TypeScript doesn't bother to check it anymore. In the case of <code>unknown</code>, it works a bit more strict, and for example in the previous code, if we want to solve the error, we must explicitly check and make sure that the <code>userInput</code> type is a <code>string</code>:
</p>
<pre><code class="language-typescript">let userInput: unknown;
let userName: string;
userInput = 5;
userInput = 'Max';
if (typeof userInput === 'string') {
  userName = userInput;
}</code></pre>
<p>
    By doing this, we don't see any more errors and we can easily compile the codes. Now Typescript understands that I am sure of the type of <code>userInput</code> variable and I have set it equal to <code>username</code> by my conscious decision. The general rule is that if you use <code>unknown</code>s, you must explicitly use an <code>if</code> condition to assign them to other variables to tell TypeScript that you are sure of its type.
</p>
<p>
    This is why, in general, <code>unknown</code> is a better choice than <code>any</code>, and if you are not sure about the type of your variable or parameter, choose <code>unknown</code> instead of <code>any</code>. Of course, this does not mean using <code>unknown</code> indiscriminately, and you should still avoid using it as much as possible. For example, one of the better methods is to use union types.
</p>
<p>
    Our next type is <code>never</code>. <code>never</code> in TypeScript is another type that can be returned by functions. For example, suppose we have a function as follows:
</p>
<pre><code class="language-typescript">function generateError(message: string, code: number) {
}</code></pre>
<p>
    The task of this function is to generate an error and it takes two parameters, the first of which is a string (error message) and the second is a number (error code). I want to <code>throw</code> an error in this function and as we know this feature is available in javascript. We can <code>throw</code> anything we want as an error:
</p>
<pre><code class="language-typescript">function generateError(message: string, code: number) {
  throw { message: message, errorCode: code };
}</code></pre>
<p>
    As you can see, I have thrown an object that has two properties: <code>message</code> and <code>errorCode</code>, and the values ​​of these properties are equal to the parameters passed to the function. Now we call it like any other function:
</p>
<pre><code class="language-typescript">function generateError(message: string, code: number) {
  throw { message: message, errorCode: code };
}
generateError('An error occurred!', 500);</code></pre>
<p>
    The result of calling this function is an error in the browser console:
</p>

<center>![Throwing an error in the browser console](https://images.ecency.com/DQmPc9H1hZ6qrAb378doT869bBfTKWMwpK2Zv6LRT5rAqkS/02_error_thrown.png)</center>

<p>
    Having helper functions in this way may be useless at first glance, but in big and real projects, such functions are always used. In these types of projects, throwing errors manually is a tedious task, especially since the errors of these types of projects are not one-line and simple like the above code, and they contain all kinds of information and other settings.
</p>
<p>
    You know that the function above returns the <code>void</code> value because it does not have a <code>return</code> statement, which is correct to some extent, but if we want to check it from a completely technical point of view, we must say that this function returns <code>never</code>! why Because this function "never" creates a value to <code>return</code>. For example, if we want to store its value in a variable:
</p>
<pre><code class="language-typescript">function generateError(message: string, code: number) {
  throw { message: message, errorCode: code };
}
const result = generateError('An error occurred!', 500);
console.log(result);</code></pre>
<p>
    And then I compile the code with <code>tsc app.ts</code>, nothing is displayed in the console part of the browser (except the error we threw with <code>throw</code>). Note that no value such as <code>undefined</code> is returned. The <code>generateError</code> function never produces any value, so it can be said that the return type of this function is both <code>void</code> and <code>never</code>.
</p>
<p>
    If you move your mouse over <code>generateError</code>, it will tell you that the type of the function is <code>void</code>, because the <code>never</code> type is a little newer and was not in the original versions of the Typescript language, so in this case, the same <code>void</code> is usually placed for such values, unless you yourself Manually set it to <code>never</code>:
</p>
<pre><code class="language-typescript">function generateError(message: string, code: number): never {
  throw { message: message, errorCode: code };
}</code></pre>
<p>
    Another example of a <code>never</code> type function is infinite loops:
</p>
<pre><code class="language-typescript">while (true) {}</code></pre>
<p>
This loop always runs and never has time to return anything, so its type is <code>never</code> in TypeScript.
</p>