downgrade node or npm

  npm -v

 2013  node -v

 2014  npm -v

 2015  sudo update-alternatives --config node

 2016  sudo update-alternatives --config npm

 2017  sudo npm install -g npm@8.19.2

 

i have node is 20.5.1 i have npm is 9.8.1 i wanna downgrade npm to 8 to 9 and node is 16 to 17

2018  npm -v

 2019  nvm install 17.9.1

 2020  sudo npm install -g n

 2021  sudo npm install -g npm@8.19.2

 2022  npm -v

 2023  which node

 2024  which npm

 2025  sudo apt-get install -y npm

 2026  npm -v

 2027  node -v

 2028  npm install

 2029  sudo n 16.20.0

 2030  nvm install 16.20.0

 2031  node -v

 2032  npm -v

 2033  npm install

 2034  npm run dev

 2035  npx mix

 2036  npm install

 2037  npm run dev

ArgumentCountError: Too few arguments to function App\Http\Requests\StorePostRequest::Illuminate\Foundation\Providers\{closure}(), 0 passed in /opt/lampp/htdocs/hpanel/training/training/laravel-tuts/laravel-11/vendor/laravel/framework/src/Illuminate/Macroable/Traits/Macroable.php on line 126 and exactly 1 expected in file /opt/lampp/htdocs/hpanel/training/training/laravel-tuts/laravel-11/

  $data = $request->validated();

𝐖𝐡𝐚𝐭 𝐰𝐢𝐥𝐥 𝐛𝐞 𝐥𝐨𝐠𝐠𝐞𝐝 𝐭𝐨 𝐭𝐡𝐞 𝐜𝐨𝐧𝐬𝐨𝐥𝐞?

 𝐖𝐡𝐚𝐭 𝐰𝐢𝐥𝐥 𝐛𝐞 𝐥𝐨𝐠𝐠𝐞𝐝 𝐭𝐨 𝐭𝐡𝐞 𝐜𝐨𝐧𝐬𝐨𝐥𝐞?

​

𝐖𝐡𝐚𝐭 𝐰𝐢𝐥𝐥 𝐛𝐞 𝐥𝐨𝐠𝐠𝐞𝐝 𝐭𝐨 𝐭𝐡𝐞 𝐜𝐨𝐧𝐬𝐨𝐥𝐞?

​

Here is the answer & explanation of this question:

​

First, we have an object named “income” with three properties:

​

1. “𝐬𝐤𝐢𝐥𝐥𝐬”, which is set to 108.

2. “𝐦𝐨𝐧𝐭𝐡𝐥𝐲”, which is a method that calculates the monthly income based on the “𝐬𝐤𝐢𝐥𝐥𝐬” value.

3. “𝐲𝐞𝐚𝐫𝐥𝐲”, which is an arrow function meant to calculate the yearly income.

​

𝐄𝐱𝐩𝐥𝐚𝐧𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 “𝐦𝐨𝐧𝐭𝐡𝐥𝐲()” 𝐦𝐞𝐭𝐡𝐨𝐝:

​

1. “𝐦𝐨𝐧𝐭𝐡𝐥𝐲()” is a regular function. When you call “𝐢𝐧𝐜𝐨𝐦𝐞.𝐦𝐨𝐧𝐭𝐡𝐥𝐲()”, this refers to the “𝐢𝐧𝐜𝐨𝐦𝐞” object.

2. “𝐭𝐡𝐢𝐬.𝐬𝐤𝐢𝐥𝐥𝐬” inside the “𝐦𝐨𝐧𝐭𝐡𝐥𝐲()” method correctly refers to “𝐢𝐧𝐜𝐨𝐦𝐞.𝐬𝐤𝐢𝐥𝐥𝐬”, which is 108.

3. So, “𝐭𝐡𝐢𝐬.𝐬𝐤𝐢𝐥𝐥𝐬 * 𝟏𝟎𝟖” becomes “𝟏𝟎𝟖 * 𝟏𝟎𝟖”, which equals 11664.

4. Therefore, “𝐢𝐧𝐜𝐨𝐦𝐞.𝐦𝐨𝐧𝐭𝐡𝐥𝐲()” returns 11664.

​

𝐄𝐱𝐩𝐥𝐚𝐧𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 “𝐲𝐞𝐚𝐫𝐥𝐲” 𝐚𝐫𝐫𝐨𝐰 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧:

​

1. “𝐲𝐞𝐚𝐫𝐥𝐲” is defined as an arrow function.

2. Arrow functions do not have their own “𝐭𝐡𝐢𝐬” context; they inherit “𝐭𝐡𝐢𝐬” from the surrounding (lexical) context at the time they are defined.

3. In this case, “𝐭𝐡𝐢𝐬” in “yearly” refers to the global object (“𝐰𝐢𝐧𝐝𝐨𝐰” in browsers, “𝐠𝐥𝐨𝐛𝐚𝐥” in Node.js), not the “𝐢𝐧𝐜𝐨𝐦𝐞” object.

4. Since there is no “𝐬𝐤𝐢𝐥𝐥𝐬” property on the global object, “𝐭𝐡𝐢𝐬.𝐬𝐤𝐢𝐥𝐥𝐬” is “𝐮𝐧𝐝𝐞𝐟𝐢𝐧𝐞𝐝”.

5. As a result, “𝟖𝟖𝟖 * 𝐭𝐡𝐢𝐬.𝐬𝐤𝐢𝐥𝐥𝐬” becomes “𝟖𝟖𝟖 * 𝐮𝐧𝐝𝐞𝐟𝐢𝐧𝐞𝐝”, which is “𝐍𝐚𝐍” (Not a Number).

6. Therefore, “𝐢𝐧𝐜𝐨𝐦𝐞.𝐲𝐞𝐚𝐫𝐥𝐲()” returns “𝐍𝐚𝐍”.

​

𝐓𝐨 𝐬𝐮𝐦𝐦𝐚𝐫𝐢𝐳𝐞:

​

1. “𝐢𝐧𝐜𝐨𝐦𝐞.𝐦𝐨𝐧𝐭𝐡𝐥𝐲()” works as expected and returns 11664 because “𝐭𝐡𝐢𝐬” correctly refers to the “𝐢𝐧𝐜𝐨𝐦𝐞” object.

2. “𝐢𝐧𝐜𝐨𝐦𝐞.𝐲𝐞𝐚𝐫𝐥𝐲()” returns “𝐍𝐚𝐍” because “𝐭𝐡𝐢𝐬” inside the arrow function does not refer to the “𝐢𝐧𝐜𝐨𝐦𝐞” object, leading to “𝐭𝐡𝐢𝐬.𝐬𝐤𝐢𝐥𝐥𝐬” being “𝐮𝐧𝐝𝐞𝐟𝐢𝐧𝐞𝐝”.

​

​

​

𝐅𝐨𝐥𝐥𝐨𝐰 𝐭𝐡𝐢𝐬 𝐩𝐚𝐠𝐞 𝐟𝐨𝐫 𝐦𝐨𝐫𝐞 𝐜𝐨𝐧𝐭𝐞𝐧𝐭 𝐥𝐢𝐤𝐞 𝐭𝐡𝐢𝐬.

english

 

 

https://www.facebook.com/diction.delhi

https://www.facebook.com/groups/977022925989523/

https://www.facebook.com/vashista360/

https://drive.google.com/file/d/1qZHw58UPGPdY0tMMdMr9PS2K34Eb8m_a/edit

https://www.facebook.com/anandraman95/reels/

sql order of execution

 We all know SQL, but most of us do not understand the internals of it.

Let me take an example to explain this better. Select p.plan_name, count(plan_id) as total_count From plans p Join subscriptions s on s.plan_id=p.plan_id Where p.plan_name !=’premium’ Group by p.plan_name Having total_count > 100 Order by p.plan_name Limit 10; Step 01: Get the table data required to run the sql query Operations: FROM, JOIN (From plans p, Join subscriptions s) Step 02: Filter the data rows Operations: WHERE (where p.plan_name=’premium’) Step 03: Group the data Operations: GROUP (group by p.plan_name) Step 04: Filter the grouped data Operations: HAVING (having total_count > 100) Step 05: Select the data columns Operations: SELECT (select p.plan_name, count(p.plan_id) Step 06: Order the data Operations: ORDER BY (order by p.plan_name) Step 07: Limit the data rows Operations: LIMIT (limit 100) Knowing the Internals really help. where does distinct keyword fits in the above ordering? Do mention in comments. #bigdata #dataengineering #sql

if two traits in same class what it wil return an dhow to call

 

 In Laravel (and PHP in general), you can import and use multiple traits within a single class. Traits are a mechanism for code reuse in single inheritance languages like PHP, allowing you to include methods and properties in a class without using inheritance.

Importing and Using Multiple Traits

1. Declare the Traits: First, ensure you have the traits defined. For example, let's say we have two traits: TraitOne and TraitTwo.

namespace App\Traits;

trait TraitOne {

    public function methodOne() {

        return "Method One from TraitOne";

    }

}

trait TraitTwo {

    public function methodTwo() {

        return "Method Two from TraitTwo";

    }

}

2. Use Traits in a Class: You can then use these traits in a class by using the use keyword within the class definition.

namespace App\Http\Controllers; use App\Traits\TraitOne; use App\Traits\TraitTwo; class ExampleController extends Controller { use TraitOne, TraitTwo; public function show() { echo $this->methodOne(); echo $this->methodTwo(); } }

In this example:

• TraitOne and TraitTwo are both imported into the ExampleController class.
• The show method calls methodOne from TraitOne and methodTwo from TraitTwo.

Full Example in Laravel

Let's assume you are creating a controller in Laravel that uses these traits.

Step 1: Define Traits

// File: app/Traits/TraitOne.php

namespace App\Traits;

trait TraitOne {

    public function methodOne() {

        return "Method One from TraitOne\n";

    }

}

// File: app/Traits/TraitTwo.php

namespace App\Traits;

trait TraitTwo {

    public function methodTwo() {

        return "Method Two from TraitTwo\n";

    }

}

tep 2: Use Traits in a Controller

// File: app/Http/Controllers/ExampleController.php

namespace App\Http\Controllers;

use App\Traits\TraitOne;

use App\Traits\TraitTwo;

class ExampleController extends Controller {

    use TraitOne, TraitTwo;

    public function show() {

        echo $this->methodOne();

        echo $this->methodTwo();

    }

}

Step 3: Define a Route to Access the Controller Method

// File: routes/web.php

use App\Http\Controllers\ExampleController;

Route::get('/example', [ExampleController::class, 'show']);

Accessing the Controller Method

Now, when you visit the route /example, you should see the output from both methods:

Method One from TraitOne Method Two from TraitTwo

Summary

• Define Traits: Create traits with the desired methods.
• Import Traits: Use the use keyword within the class definition to import multiple traits.
• Call Trait Methods: Call the trait methods as if they are part of the class.

This allows for flexible and reusable code, making it easy to share functionality across different parts of your application.

if same method in two traits , will it throw error or any

If a class uses multiple traits that contain methods with the same name, it will result in a fatal error due to the method name conflict. However, PHP provides a way to resolve this conflict using insteadof and as operators within the use statement of the class.

Resolving Method Name Conflicts with insteadof

You can specify which trait's method should be used when there is a conflict. Here’s how you can resolve the conflict:

1. Define the Traits with Conflicting Methods:

php
namespace App\Traits;

trait TraitOne {
    public function conflictMethod() {
        return "Method from TraitOne";
    }
}

trait TraitTwo {
    public function conflictMethod() {
        return "Method from TraitTwo";
    }
}

2. Use Traits in a Class and Resolve Conflict:

php
namespace App\Http\Controllers;

use App\Traits\TraitOne;
use App\Traits\TraitTwo;

class ExampleController extends Controller {
    use TraitOne, TraitTwo {
        TraitOne::conflictMethod insteadof TraitTwo;
        TraitTwo::conflictMethod as conflictMethodFromTraitTwo;
    }

    public function show() {
        echo $this->conflictMethod(); // Calls TraitOne's method
        echo $this->conflictMethodFromTraitTwo(); // Calls TraitTwo's method
    }
}

Explanation:

• insteadof Operator: The insteadof operator specifies which trait's method to use in case of a conflict. In the example, TraitOne::conflictMethod insteadof TraitTwo means that the conflictMethod from TraitOne will be used, not the one from TraitTwo.

• as Operator: The as operator allows you to rename a method from a trait. This can be useful if you still want to use the method from the other trait under a different name. In the example, TraitTwo::conflictMethod as conflictMethodFromTraitTwo renames conflictMethod from TraitTwo to conflictMethodFromTraitTwo.

Full Example in Laravel

Step 1: Define Traits with Conflicting Methods

php
// File: app/Traits/TraitOne.php
namespace App\Traits;

trait TraitOne {
    public function conflictMethod() {
        return "Method from TraitOne\n";
    }
}

// File: app/Traits/TraitTwo.php
namespace App\Traits;

trait TraitTwo {
    public function conflictMethod() {
        return "Method from TraitTwo\n";
    }
}

Step 2: Use Traits in a Controller and Resolve Conflict

php
// File: app/Http/Controllers/ExampleController.php
namespace App\Http\Controllers;

use App\Traits\TraitOne;
use App\Traits\TraitTwo;

class ExampleController extends Controller {
    use TraitOne, TraitTwo {
        TraitOne::conflictMethod insteadof TraitTwo;
        TraitTwo::conflictMethod as conflictMethodFromTraitTwo;
    }

    public function show() {
        echo $this->conflictMethod(); // Outputs: Method from TraitOne
        echo $this->conflictMethodFromTraitTwo(); // Outputs: Method from TraitTwo
    }
}

Step 3: Define a Route to Access the Controller Method

php
// File: routes/web.php
use App\Http\Controllers\ExampleController;

Route::get('/example', [ExampleController::class, 'show']);

Accessing the Controller Method

When you visit the route /example, you will see the output from both methods:

sql
Method from TraitOne
Method from TraitTwo

Summary

• Method Name Conflict: If traits contain methods with the same name, it causes a conflict.
• Resolving Conflict: Use insteadof to specify which method to use and as to alias the other method.
• Example Usage: By resolving conflicts, you can use methods from multiple traits even if they have the same name, ensuring flexibility and code reuse.