DART: can some explain this line to me?-CodePudding

I'm learning Dart & Flutter, but I'm struggling with some basic programming issues like the use of getters:

GoogleSignInAccount get user => _user!;

What's the equivalent of the "get" method?

What does the ! at the end of a variable mean?

Thanks in advance!

CodePudding user response：

That is a getter, in Java that code might look like:

public GoogleSignInAccount getGoogleUser(){ return this.user; }

Dart likes that code written more succinctly.

In Dart private class members are denoted via a _ in front of the variable/function name. So the variable that the getter is returning is a private variable, hence _user.

The ! at the end of the variable name has to do with Dart null safety. Throwing a ! at the end of the variable name is functionally the equivalent of saying assert _user != null; what it actually does is cast a nullable data type to its non-nullable equivalent.

In Dart, all data has two types, a nullable type, denoted by a ? at the end of the data type declaration, and a non nullable type.

The _user variable, it can be assumed from this code, is of the type GoogleSignInAccount? meaning that it can be null. However the getter wants to return a GoogleSignInAccount. Because there is no question mark on the end, the type the getter returns must NOT be null. So we put ! on the end of the _user variable to denote that we want to cast the nullable type to its not null form.

Note also that the name of this function is user and that in Dart you can have two functions of the same name if one is a getter and the other is a setter. To denote getter versus setter in a function declaration, you use the get and set keywords as you see above.

If you want to get a good idea of how getters and setters look in Dart, make a class with some variables. Make sure all of the variable names start with _ so that they are private, then right click in your IDE and tell it to generate some getters and setters for you. I believe both Android Studio and VSCode have the Generate option in their right click menu.

CodePudding user response：

The exclamation mark at the end of the private variable tells the compiler that the variable is not null and the user data returned by the getter must not be null.

CodePudding user response：

There are two things at play here:

GoogleSignInAccount get user => _user!;

does the same as

GoogleSignInAccount user() {
  return _user;
}

Where the first one is called a getter.

As a getter you can access it like a property. For example

myUser = userService.user;

With the function notation you access it like

myUser = userService.user();

Since you do not calculate anything but only expose that private member the getter notation is more succinct.

Regarding the !:

Dart is null safe, which means types without a ? can't be null.

In your case the _user is a GoogleSignInAccount? which means it can be null. For example on startup when the user isn't signed in yet.

The getter GoogleSignInAccount get user has the type GoogleSignInAccount which means the compiler gives you an error when you try to assign null to it.

So user can not be null. _user could be null.

With the ! you promise to the compiler that you know that the _user is in no case null when the getter user is called.

Example: This could be the case if the user is loaded right on startup while a progress indicator is shown. When the user is loaded you start the whole app and now you can access the user with user!. You are sure that the user is loaded. If you somehow access the user before it's loaded (while it's still null) you get a runtime error.

Null safety just helps you to think about wheter a variable can be null and to avoid NullPointerExceptions.