Since switching to TypeScript I have been using a lot of optional properties, for example:

type store = {
  currentUserId?: string
}

function logout () {
  store.currentUserId = undefined
}

However my coworkers and I have been discussing whether null is a more appropriate type instead of undefined, like this:

type store = {
  currentUserId: string | null
}

function logout () {
  store.currentUserId = null
}

It seems like the use of undefined in TypeScript differs slightly from in Javascript.

Do you guys/girls use undefined or null more often? And, which of the examples above do you think is better?

Hey! What are your thoughts on explicit returning undefined in a function vs returning null, this in the absence of what you asked the function for.
Let's take these functions as an example
type getUser = (id: string): User | undefined vs type getUser = (id: string): User | NULL
What are your thoughts on this? Good and bad etc

Maybe our GraphQL schema is bad, I don't know. I just work on the frontend.

I'm having problems like this when I turn strict non-null checks on:

Type 'Maybe<number>' is not assignable to type 'number | undefined'.
  Type 'null' is not assignable to type 'number | undefined'.ts(2322)

Variable that I have is from GraphQL codegen: Maybe<number>

I want to put it into here?: number;

Can I do something graphQL codegen settings? Preferably.

I can't play with the schema itself, not easily.

I can't change the whole app and turn everything into here?: number | null; that is too verbose and feels stupid, there must be a better way.

What do people think of the ability to have multiple types like this? I found it super annoying when mapping between objects. If the same property names are used but one is string but the other property from the other class is string | null, the IDE complains. Are there any situations where you've found it helpful to be able to declare at type like this?

Hello guys, i need your help, i would like to know which you think is a better approach:

1 --------------------------------------------
const {content} = props;
if(content !== "undefined"){

//code

}

2 --------------------------------------------
const {content = null} = props;
if(!content){

//code

}

export interface UserTable {
  user_id: Generated<number>,
  alternate_user_id: Generated<number> | null,
  personnel_id: number | undefined,
  company_id: number | null,
  email: string | undefined,
  email_verified: boolean | null
}

When creating a type definition what am I supposed to use to indicate that a column might not have a value at creation? Undefined? Null? I figure I will include ' | null' for every column that is nullable? So what is the purpose of undefined in type definitions??

I am using Kysely, and Postgresql

EDIT: The above code isn't real, just filler as an example.

   protected combineAndSave(
      audiosAndPauseFiles: Array<string>
      , savePath: string
      , filePrefix?: string
      , fileName?: string
   ): void {

I noticed when calling this, I had to specify undefined on the 3rd arg (4th will be implicitly undefined if not specified). Is that the best way to do it? In general I think null is more explicit but maybe that does apply for this case.

Also if anyone knows a way to more tightly constrain this method so that one of the last two params must be specifed, I appreciate any further advice on that front.

What do you prefer to check for null and undefined?

Feel free to comment on why which one is better.