Forem: Ida Bagus Gede Pramana Adi Putra

Difference between isset() vs empty() vs is_null() in PHP

Ida Bagus Gede Pramana Adi Putra — Tue, 18 Oct 2022 01:43:41 +0000

There are some built-in PHP functions that are similar to each other, and those are isset(), empty() and is_null().

isset() method

If the variable has been set with a value, this method will return true. Otherwise, it will return false.

isset() syntax

isset(variable, ….);

isset() can take many variables as its argument, see variable, ...) on the syntax. If we put many variables into the parameter, then this method will only return true if all the variable has already been set with value.

isset() examples

Let's implement isset() method to accept two variables as its argument. On the first variable, we will assign a null as its value, and on the second variable, we will assign a string or any other data type other than null.

<?php
$name = null;
$result = isset($name); 

var_dump($result); // bool(false)

The result from the snippet above is bool(false) as the variable that we assigned with a value was null.

However, if we assign the value with other data type than null, such example:

<?php
$name = "Pramana";
$result = isset($nama); 

var_dump($result); // bool(true)

The code snippet above will return bool(true) because we assigned a string to the variable. Any value with a data type other than null will be interpreted as a non-null variable, therefore it returns true.

empty() method

empty() is a built-in function in PHP that's intended to check whether a variable is empty or has not been set with any value. This method returns either true or false.

empty() syntax

empty( $variable )

empty() only accept one parameter as its argument, as the syntax shows.

empty() example

Let's implement empty() with two variables, on the first variable, we will set it with a null value, and a string value for the second variable.

<?php
$name = null;
$result = empty($name); 

var_dump($result); // bool(true)

The code snippet above will return true as the result. It's because the empty() checks whether a variable is empty, and a null value is considered as empty, thus it returns true.

The answer is nope as it depends on the string length.

<?php
$name = "";
$result = empty($name); 

var_dump($result); // bool(true)

The code above returns true even though it's assigned with a string and not null. This is because we assigned "" which is an empty string. The "" has no value, it's only a string but empty, and that's why it returns true.

It's a little bit tricky.

What if we assigned the variable with an integer, but the integer is 0.

$number = 0;
var_dump(empty($number)); // bool(true)

This is also returning true, because 0 is considered as empty when we validate it against empty() method. If it was assigned with another integer other than 0, then the result would be false.

is_null() method

is_null() is a PHP built-in function to check whether a variable is assigned a null value. This method returns a boolean true or false.

is_null method

is_null( $variable )

is_null method only accepts one parameter as its argument.

Let's implement is_null method against two variables, the first variable will hold a null value, and a non-value on the second variable.

<?php
$name = null;
$result = is_null($name); 

var_dump($result); // bool(true)

The code above returns true because $name variable holds a null value.

<?php
$name = "Pramana";
$result = is_null($name); 

var_dump($result); // bool(false)

However, if we use the is_null() method against a non-null value, we will get false as the result.

References:

3 Best Alternatives to Figma

Ida Bagus Gede Pramana Adi Putra — Tue, 11 Oct 2022 10:28:44 +0000

Figma is undoubtedly one of the best applications for designing rich user interfaces and other 2d graphics, however, recent news said Adobe acquired Figma has led most Figma users to be concerned about the platform.

For those who are looking for Figma alternatives, we have a list of the best options to replace Figma that are open source and free to use.

Penpot

Penpot is the first design and prototype cross-platform that is open source and yet already becoming the best alternative to Figma (in my opinion). For those who are using Figma to collaborate with team when designing, Penpot allows you to do the same, for free.

Penpot Advantages over Figma

It's open source
Very similar to Figma, new users will have no difficulty in adapting
Web-based and supports SVG
It has the most basic Figma features
Collaboration feature for team with projects
Free to use, without any fee.

Penpot Disadvantages

There's no version control
New product, not as mature as Figma
It is still in Beta version, which is requiring user feedback
Not many plugins or community assets

Icons8 Lunacy

Lunacy is a user interface design tool offered by the platform that provides icons and graphics you already knew, Icons 8.

Lunacy Advantages over Figma

Support many design format that comes from Figma, Adobe XD, Sketch, Avocado, etc.
User interface that is very similar looking to Figma makes new users will face no difficulty to adapt Antarmuka aplikasi yang sangat mirip dengan Figma membuat pengguna baru mudah untuk beradaptasi
AI support
Integration with graphics and icons from Icons8
Terintegrasi dengan berbagai grafis dan ikon yang tersedia di Icons8
Gratis untuk pengguna individu
Free for individual use

Lunacy Disadvantages over Figma

Unlike Figma, Lunacy is a standalone app (requires installation, it's not a web-based)
Unlike Penpot, it's not an open source
It has a collaboration feature, but not free.

Wireflow

Wireflow is a design tool that focus on creating wireframe and user flow.

Wireflow advantages over Figma

Open Source
Many templates for getting started
Generates functioning code in real-time as you design.
Free to use
Most suitable for designing user flow

Wireflow disadvantages over Figma

Components are not customizable
It has no collaboration feature
A bit confusing
Again, just for designing simple wireframe and user-flow

Conclusion

Searching for the best alternative to a mature product like Figma is not easy, especially since Figma is a web-based application made with WebAssembly that allows it to have complex design features that are very light and powerful.

By far the best alternative to Figma is Penpot.app which is open source and with a similar interface and overall features.

Original source: 3 Best & Open Source Alternatives to Figma

As A Developer Who Uses MongoDB for Years, Why You Wouldn't Recommend it over MySQL?

Ida Bagus Gede Pramana Adi Putra — Tue, 23 Jul 2019 05:05:52 +0000

Any developer who uses MongoDB out there?

In which situation you would recommend it to use MongoDB instead of MySQL, or why you wouldn't recommend it over MySQL?

What framework you're currently use and why?

Ida Bagus Gede Pramana Adi Putra — Wed, 05 Jun 2019 08:59:31 +0000

There are dozens of development framework out there, what you're currently use and why?

Laravel: How to let user login with Email or Username

Ida Bagus Gede Pramana Adi Putra — Tue, 04 Jun 2019 14:34:07 +0000

Laravel by default only let users to login with their Email Address. Now, what if you want to let your users to login with email or even username..?

To achieve this, you only have to change some codes in the Laravel default authentication codes.

Let's start. And I assume you've already set up your Laravel project and migrating Laravel default auth. If you haven't just write command php artisan make:auth and then php artisan migrate.

The commands above make Laravel provides basic and default authentication for you, so you don't have to make Login, Register, Forgot Password & Reset Password manually.

Step by step

Open loginController.php
By default, you will only see these codes inside your login controller

<?php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\AuthenticatesUsers;

class LoginController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Login Controller
    |--------------------------------------------------------------------------
    |
    | This controller handles authenticating users for the application and
    | redirecting them to your home screen. The controller uses a trait
    | to conveniently provide its functionality to your applications.
    |
    */

    use AuthenticatesUsers;

    /**
     * Where to redirect users after login.
     *
     * @var string
     */
    protected $redirectTo = '/home';

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('guest')->except('logout');
    }
}

This controller only has attributes and one constructor, so how does it handle the login function? It's where the OOP plays its part.

Notice there's use AuthenticatesUsers; statement, and this is where Laravel built its default login functionality. So now, let's check the AuthenticateUsers class.

<?php

namespace Illuminate\Foundation\Auth;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\ValidationException;

trait AuthenticatesUsers
{
    use RedirectsUsers, ThrottlesLogins;

    /**
     * Show the application's login form.
     *
     * @return \Illuminate\Http\Response
     */
    public function showLoginForm()
    {
        return view('auth.login');
    }

    /**
     * Handle a login request to the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\RedirectResponse|\Illuminate\Http\Response|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Validation\ValidationException
     */
    public function login(Request $request)
    {
        $this->validateLogin($request);

        // If the class is using the ThrottlesLogins trait, we can automatically throttle
        // the login attempts for this application. We'll key this by the username and
        // the IP address of the client making these requests into this application.
        if (method_exists($this, 'hasTooManyLoginAttempts') &&
            $this->hasTooManyLoginAttempts($request)) {
            $this->fireLockoutEvent($request);

            return $this->sendLockoutResponse($request);
        }

        if ($this->attemptLogin($request)) {
            return $this->sendLoginResponse($request);
        }

        // If the login attempt was unsuccessful we will increment the number of attempts
        // to login and redirect the user back to the login form. Of course, when this
        // user surpasses their maximum number of attempts they will get locked out.
        $this->incrementLoginAttempts($request);

        return $this->sendFailedLoginResponse($request);
    }

    /**
     * Validate the user login request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     *
     * @throws \Illuminate\Validation\ValidationException
     */
    protected function validateLogin(Request $request)
    {
        $request->validate([
            $this->username() => 'required|string',
            'password' => 'required|string',
        ]);
    }

    /**
     * Attempt to log the user into the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return bool
     */
    protected function attemptLogin(Request $request)
    {
        return $this->guard()->attempt(
            $this->credentials($request), $request->filled('remember')
        );
    }

    /**
     * Get the needed authorization credentials from the request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    protected function credentials(Request $request)
    {
        return $request->only($this->username(), 'password');
    }

    /**
     * Send the response after the user was authenticated.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    protected function sendLoginResponse(Request $request)
    {
        $request->session()->regenerate();

        $this->clearLoginAttempts($request);

        return $this->authenticated($request, $this->guard()->user())
                ?: redirect()->intended($this->redirectPath());
    }

    /**
     * The user has been authenticated.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  mixed  $user
     * @return mixed
     */
    protected function authenticated(Request $request, $user)
    {
        //
    }

    /**
     * Get the failed login response instance.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Symfony\Component\HttpFoundation\Response
     *
     * @throws \Illuminate\Validation\ValidationException
     */
    protected function sendFailedLoginResponse(Request $request)
    {
        throw ValidationException::withMessages([
            $this->username() => [trans('auth.failed')],
        ]);
    }

    /**
     * Get the login username to be used by the controller.
     *
     * @return string
     */
    public function username()
    {
        return 'email';
    }

    /**
     * Log the user out of the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function logout(Request $request)
    {
        $this->guard()->logout();

        $request->session()->invalidate();

        return $this->loggedOut($request) ?: redirect('/');
    }

    /**
     * The user has logged out of the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return mixed
     */
    protected function loggedOut(Request $request)
    {
        //
    }

    /**
     * Get the guard to be used during authentication.
     *
     * @return \Illuminate\Contracts\Auth\StatefulGuard
     */
    protected function guard()
    {
        return Auth::guard();
    }
}

If you are a beginner and just new to the OOP world, you might be feeling overwhelming when you look at these lines of code. But don't. Now we've taken a look inside the class that handles login functionality, and now your question would likely be "how do we customize it to fulfil our needs?"

Well, you don't! Remember that the location of' AuthenticateUsers' class is at Illuminate\Foundation\Auth\AuthenticatesUsers under Vendor directory. Don't edit or change whatever lies in this class, or your Composer will upset!.

Laravel is an Object-Oriented framework. So we are applying the overriding OOP method.

We want our app to let user login with either email or username, so let's take a look at which method that handles this part inside AuthenticateUsers. And you may have already noticed that this method username() describe what it does.

/**
* Get the login username to be used by the controller.
*
* @return string
*/
public function username()
{
    return 'email';
}

That comment above tells us that it returns email as the login username that used by the controller. Now, this is the method that we have to override.

Copy and paste that username() method to your loginController.php. Now instead of returning email, we need a way to return either email or username.

Now here's the part where we have to check our login form. In our default login form, look for the default email input and change the name from name="email" to name="identity". Later, it sends identity as an HTTP request to our Laravel.

Back to username() method again, we need to implement a way to check whether the HTTP request email that comes in as an email address or username. We can do this by checking if there's an "@" within the data that sent. Luckily PHP has built a function to do this. If there's an "@", then the HTTP request email is indeed an email address. Otherwise, it's a username.

/**
* Get the login username to be used by the controller.
*
* @return string
*/
public function username()
{
     $login = request()->input('identity');

     $field = filter_var($login, FILTER_VALIDATE_EMAIL) ? 'email' : 'username';
     request()->merge([$field => $login]);

     return $field;
}

What the above code does is to filter the HTTP request that comes in if there's an @ or if it's an email by using FILTER_VALIDATE_EMAIL. If it's an email then return email, otherwise, return username.

After doing this, we only have one to-do left, and it's to overriding the validation request. In your login controller class, add these codes below:

/**
     * Validate the user login request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return void
     *
     * @throws \Illuminate\Validation\ValidationException
     */
    protected function validateLogin(Request $request)
    {
        $messages = [
            'identity.required' => 'Email or username cannot be empty',
            'email.exists' => 'Email or username already registered',
            'username.exists' => 'Username is already registered',
            'password.required' => 'Password cannot be empty',
        ];

        $request->validate([
            'identity' => 'required|string',
            'password' => 'required|string',
            'email' => 'string|exists:users',
            'username' => 'string|exists:users',
        ], $messages);
    }

The default validation only checks for the email, now we've changed it to also check for both email and username.

Now you have a working solution to let your user login with either an email address or username.

If you have any question, just let me know :)

This post updated on Mei, 5th, 2020. Fixed some grammar mistakes, for a better reading experience for future readers.