[tutorial] Bab 9 Cheatsheet Laravel 5.1



// Added in 5.1.11:http://laravel.com/docs/5.1/authorization#creating-policies
php artisan make:policy PostPolicy
// Displays help for a given command
php artisan --help OR -h
// Do not output any message
php artisan --quiet OR -q
// Display this application version
php artisan --version OR -V
// Do not ask any interactive question
php artisan --no-interaction OR -n
// Force ANSI output
php artisan --ansi
// Disable ANSI output
php artisan --no-ansi
// The environment the command should run under
php artisan --env
// -v|vv|vvv Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
php artisan --verbose
// Remove the compiled class file
php artisan clear-compiled
// Display the current framework environment
php artisan env
// Displays help for a command
php artisan help
// Lists commands
php artisan list
// Interact with your application
php artisan tinker
// Put the application into maintenance mode
php artisan down
// Bring the application out of maintenance mode
php artisan up
// Optimize the framework for better performance
// --force    Force the compiled class file to be written.
// --psr      Do not optimize Composer dump-autoload.
php artisan optimize [--force] [--psr]
// Serve the application on the PHP development server
php artisan serve
// Change the default port
php artisan serve --port 8080
// Get it to work outside localhost
php artisan serve --host
// Set the application namespace
php artisan app:name namespace
// Flush expired password reset tokens
php artisan auth:clear-resets
// Flush the application cache
php artisan cache:clear
// Create a migration for the cache database table
php artisan cache:table
// Create a cache file for faster configuration loading
php artisan config:cache
// Remove the configuration cache file
php artisan config:clear
// In program
$exitCode = Artisan::call('config:cache');
// Seed the database with records
// --class      The class name of the root seeder (default: "DatabaseSeeder")
// --database   The database connection to seed
// --force      Force the operation to run when in production.
php artisan db:seed [--class[="..."]] [--database[="..."]] [--force]

// Generate the missing events and handlers based on registration
php artisan event:generate

// Create a new command handler class
// --command      The command class the handler handles.
php artisan handler:command [--command="..."] name
// Create a new event handler class
// --event        The event class the handler handles.
// --queued       Indicates the event handler should be queued.
php artisan handler:event [--event="..."] [--queued] name

// Set the application key
php artisan key:generate

// By default, this creates a self-handling command that isn't pushed to the queue.
// Pass this the --handler flag to generate a handler, and the --queued flag to make it queued.
php artisan make:command [--handler] [--queued] name
// Create a new Artisan command
//  --command     The terminal command that should be assigned. (default: "command:name")
make:console [--command[="..."]] name
// Create a new resourceful controller
// --plain      Generate an empty controller class.
php artisan make:controller [--plain] name
php artisan make:controller App\Admin\Http\Controllers\DashboardController
// Create a new event class
php artisan make:event name
// Create a new middleware class
php artisan make:middleware name
// Create a new migration file
// --create     The table to be created.
// --table      The table to migrate.
php artisan make:migration [--create[="..."]] [--table[="..."]] name
// Create a new Eloquent model class
php artisan make:model name
// Create a new service provider class
php artisan make:provider name
// Create a new form request class
php artisan make:request name
// Database migrations
// --database   The database connection to use.
// --force      Force the operation to run when in production.
// --path       The path of migrations files to be executed.
// --pretend    Dump the SQL queries that would be run.
// --seed       Indicates if the seed task should be re-run.
php artisan migrate [--database[="..."]] [--force] [--path[="..."]] [--pretend] [--seed]
// Create the migration repository
php artisan migrate:install [--database[="..."]]
// Create a new migration file
// --seeder     The class name of the root seeder.
php artisan migrate:refresh [--database[="..."]] [--force] [--seed] [--seeder[="..."]]
// Rollback all database migrations
// --pretend    Dump the SQL queries that would be run.
php artisan migrate:reset [--database[="..."]] [--force] [--pretend]
// Rollback the last database migration
php artisan migrate:rollback [--database[="..."]] [--force] [--pretend]
// Show a list of migrations up/down
php artisan migrate:status
// Create a migration for the queue jobs database table
php artisan queue:table
// Listen to a given queue
// --queue      The queue to listen on
// --delay      Amount of time to delay failed jobs (default: 0)
// --memory     The memory limit in megabytes (default: 128)
// --timeout    Seconds a job may run before timing out (default: 60)
// --sleep      Seconds to wait before checking queue for jobs (default: 3)
// --tries      Number of times to attempt a job before logging it failed (default: 0)
php artisan queue:listen [--queue[="..."]] [--delay[="..."]] [--memory[="..."]] [--timeout[="..."]] [--sleep[="..."]] [--tries[="..."]] [connection]
// List all of the failed queue jobs
php artisan queue:failed
// Create a migration for the failed queue jobs database table
php artisan queue:failed-table
// Flush all of the failed queue jobs
php artisan queue:flush
// Delete a failed queue job
php artisan queue:forget
// Restart queue worker daemons after their current job
php artisan queue:restart
// Retry a failed queue job(id: The ID of the failed job)
php artisan queue:retry id
// Subscribe a URL to an Iron.io push queue
// queue: The name of Iron.io queue.
// url: The URL to be subscribed.
// --type       The push type for the queue.
php artisan queue:subscribe [--type[="..."]] queue url
// Process the next job on a queue
// --queue      The queue to listen on
// --daemon     Run the worker in daemon mode
// --delay      Amount of time to delay failed jobs (default: 0)
// --force      Force the worker to run even in maintenance mode
// --memory     The memory limit in megabytes (default: 128)
// --sleep      Number of seconds to sleep when no job is available (default: 3)
// --tries      Number of times to attempt a job before logging it failed (default: 0)
php artisan queue:work [--queue[="..."]] [--daemon] [--delay[="..."]] [--force] [--memory[="..."]] [--sleep[="..."]] [--tries[="..."]] [connection]

// Create a route cache file for faster route registration
php artisan route:cache
// Remove the route cache file
php artisan route:clear
// List all registered routes
php artisan route:list

// Run the scheduled commands
php artisan schedule:run

// Create a migration for the session database table
php artisan session:table

// Publish any publishable assets from vendor packages
// --force        Overwrite any existing files.
// --provider     The service provider that has assets you want to publish.
// --tag          The tag that has assets you want to publish.
php artisan vendor:publish [--force] [--provider[="..."]] [--tag[="..."]]
php artisan tail [--path[="..."]] [--lines[="..."]] [connection]


composer create-project laravel/laravel folder_name
composer install
composer update
composer dump-autoload [--optimize]
composer self-update
composer require [options] [--] [vendor/packages]...


//get with Default value
Config::get('app.timezone', 'UTC');
//set Configuration
Config::set('database.default', 'sqlite');


Route::get('foo', function(){});
Route::get('foo', 'ControllerName@function');
Route::controller('foo', 'FooController');
RESTful Controllers
//Specify a subset of actions to handle on the route
Route::resource('photo', 'PhotoController',['only' => ['index', 'show']]);
Route::resource('photo', 'PhotoController',['except' => ['update', 'destroy']]);
Triggering Errors
$handler->missing(...) in ErrorServiceProvider::boot();
throw new NotFoundHttpException;
Route Parameters
Route::get('foo/{bar}', function($bar){});
Route::get('foo/{bar?}', function($bar = 'bar'){});
HTTP Verbs
Route::any('foo', function(){});
Route::post('foo', function(){});
Route::put('foo', function(){});
Route::patch('foo', function(){});
Route::delete('foo', function(){});
// RESTful actions
Route::resource('foo', 'FooController');
// Registering A Route For Multiple Verbs
Route::match(['get', 'post'], '/', function(){});
Secure Routes(TBD)
Route::get('foo', array('https', function(){}));
Route Constraints
Route::get('foo/{bar}', function($bar){})
->where('bar', '[0-9]+');
Route::get('foo/{bar}/{baz}', function($bar, $baz){})
->where(array('bar' => '[0-9]+', 'baz' => '[A-Za-z]'))
// Set a pattern to be used across routes
Route::pattern('bar', '[0-9]+')
HTTP Middleware
// Assigning Middleware To Routes
Route::get('admin/profile', ['middleware' => 'auth', function(){}]);
Route::get('admin/profile', function(){})->middleware('auth');
Named Routes
Route::get('foo/bar', array('as' => 'foobar', function(){}));
Route::get('user/profile', [
'as' => 'profile', 'uses' => 'UserController@showProfile'
Route::get('user/profile', 'UserController@showProfile')->name('profile');
$url = route('profile');
$redirect = redirect()->route('profile');
Route Prefixing
Route::group(['prefix' => 'admin'], function()
Route::get('users', function(){
    return 'Matches The "/admin/users" URL';
Route Namespacing
// This route group will carry the namespace 'Foo\Bar'
Route::group(array('namespace' => 'Foo\Bar'), function(){})
Sub-Domain Routing
// {sub} will be passed to the closure
Route::group(array('domain' => '{sub}.example.com'), function(){});


$environment = app()->environment();
$environment = App::environment();
$environment = $app->environment();
// The environment is local
if ($app->environment('local')){}
// The environment is either local OR staging...
if ($app->environment('local', 'staging')){}


// The logger provides the seven logging levels defined in RFC 5424:
// debug, info, notice, warning, error, critical, and alert.
Log::info('info',array('context'=>'additional info'));
// get monolog instance
// add listener
Log::listen(function($level, $message, $context) {});
Query Logging
// enable the log
// get an array of the executed queries


URL::to('foo/bar', $parameters, $secure);
URL::action('NewsController@item', ['id'=>123]);
// need be in appropriate namespace
URL::action('FooController@method', $parameters, $absolute);
URL::route('foo', $parameters, $absolute);
URL::secure('foo/bar', $parameters);
URL::asset('css/foo.css', $secure);


Event::fire('foo.bar', array($bar));
// Register an event listener with the dispatcher.
// void listen(string|array $events, mixed $listener, int $priority)
Event::listen('App\Events\UserSignup', function($bar){});
Event::listen('foo.*', function($bar){});
Event::listen('foo.bar', 'FooHandler', 10);
Event::listen('foo.bar', 'BarHandler', 5);
// Stopping The Propagation Of An Event
// You may do so by returning false from your handler.
Event::listen('foor.bar', function($event){ return false; });


Basic Database Usage
// Running A Select Query
$results = DB::select('select * from users where id = ?', [1]);
$results = DB::select('select * from users where id = :id', ['id' => 1]);
// Running A General Statement
DB::statement('drop table users');
// Listening For Query Events
DB::listen(function($sql, $bindings, $time){ code_here; });
// Database Transactions
DB::table('users')->update(['votes' => 1]);
Query Builder
// Retrieving All Rows From A Table
// Chunking Results From A Table
DB::table('users')->chunk(100, function($users)
foreach ($users as $user)
// Retrieving A Single Row From A Table
$user = DB::table('users')->where('name', 'John')->first();
// Retrieving A Single Column From A Row
$name = DB::table('users')->where('name', 'John')->pluck('name');
// Retrieving A List Of Column Values
$roles = DB::table('roles')->lists('title');
$roles = DB::table('roles')->lists('title', 'name');
// Specifying A Select Clause
$users = DB::table('users')->select('name', 'email')->get();
$users = DB::table('users')->distinct()->get();
$users = DB::table('users')->select('name as user_name')->get();
// Adding A Select Clause To An Existing Query
$query = DB::table('users')->select('name');
$users = $query->addSelect('age')->get();
// Using Where Operators
$users = DB::table('users')->where('votes', '>', 100)->get();
$users = DB::table('users')
            ->where('votes', '>', 100)
            ->orWhere('name', 'John')
$users = DB::table('users')
            ->whereBetween('votes', [1, 100])->get();
$users = DB::table('users')
            ->whereNotBetween('votes', [1, 100])->get();
$users = DB::table('users')
            ->whereIn('id', [1, 2, 3])->get();
$users = DB::table('users')
            ->whereNotIn('id', [1, 2, 3])->get();
$users = DB::table('users')
// Dynamic Where Clauses
$admin = DB::table('users')->whereId(1)->first();
$john = DB::table('users')
            ->whereIdAndEmail(2, 'john@doe.com')
$jane = DB::table('users')
            ->whereNameOrAge('Jane', 22)
// Order By, Group By, And Having
$users = DB::table('users')
            ->orderBy('name', 'desc')
            ->having('count', '>', 100)
DB::table('name')->having('count', '>', 100)->get();
// Offset & Limit
$users = DB::table('users')->skip(10)->take(5)->get();
// Basic Join Statement
        ->join('contacts', 'users.id', '=', 'contacts.user_id')
        ->join('orders', 'users.id', '=', 'orders.user_id')
        ->select('users.id', 'contacts.phone', 'orders.price')
// Left Join Statement
    ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
// select * from users where name = 'John' or (votes > 100 and title <> 'Admin')
        ->where('name', '=', 'John')
            $query->where('votes', '>', 100)
                    ->where('title', '<>', 'Admin');
$users = DB::table('users')->count();
$price = DB::table('orders')->max('price');
$price = DB::table('orders')->min('price');
$price = DB::table('orders')->avg('price');
$total = DB::table('users')->sum('votes');
Raw Expressions
$users = DB::table('users')
                ->select(DB::raw('count(*) as user_count, status'))
                ->where('status', '<>', 1)
// return rows
DB::select('select * from users where id = ?', array('value'));
// return nr affected rows
DB::insert('insert into foo set bar=2');
DB::update('update foo set bar=2');
DB::delete('delete from bar');
// returns void
DB::statement('update foo set bar=2');
// raw expression inside a statement
DB::table('name')->select(DB::raw('count(*) as count, column2'))->get();
Inserts / Updates / Deletes / Unions / Pessimistic Locking
// Inserts
['email' => 'john@example.com', 'votes' => 0]
$id = DB::table('users')->insertGetId(
['email' => 'john@example.com', 'votes' => 0]
['email' => 'taylor@example.com', 'votes' => 0],
['email' => 'dayle@example.com', 'votes' => 0]
// Updates
        ->where('id', 1)
        ->update(['votes' => 1]);
DB::table('users')->increment('votes', 5);
DB::table('users')->decrement('votes', 5);
DB::table('users')->increment('votes', 1, ['name' => 'John']);
// Deletes
DB::table('users')->where('votes', '<', 100)->delete();
// Unions
// The unionAll() method is also available, and has the same method signature as union.
$first = DB::table('users')->whereNull('first_name');
$users = DB::table('users')->whereNull('last_name')->union($first)->get();
// Pessimistic Locking
DB::table('users')->where('votes', '>', 100)->sharedLock()->get();
DB::table('users')->where('votes', '>', 100)->lockForUpdate()->get();


Basic Usage
// Defining An Eloquent Model
class User extends Model {}
// generate Eloquent models
php artisan make:model User
// specify a custom table name
class User extends Model {
protected $table = 'my_users';
Model::create(array('key' => 'value'));
// Find first matching record by attributes or create
Model::firstOrCreate(array('key' => 'value'));
// Find first record by attributes or instantiate
Model::firstOrNew(array('key' => 'value'));
// Create or update a record matching attibutes, and fill with values
Model::updateOrCreate(array('search_key' => 'search_value'), array('key' => 'value'));
// Fill a model with an array of attributes, beware of mass assignment!
// Find using dual primary key
Model::find(array('first', 'last'));
// Throw an exception if the lookup fails
// Find using dual primary key and throw exception if the lookup fails
Model::findOrFail(array('first', 'last'));
Model::where('foo', '=', 'bar')->get();
Model::where('foo', '=', 'bar')->first();
Model::where('foo', '=', 'bar')->exists();
// dynamic
// Throw an exception if the lookup fails
Model::where('foo', '=', 'bar')->firstOrFail();
Model::where('foo', '=', 'bar')->count();
Model::where('foo', '=', 'bar')->delete();
//Output raw query
Model::where('foo', '=', 'bar')->toSql();
Model::whereRaw('foo = bar and cars = 2', array(20))->get();
// Default Eloquent sort is ascendant
Soft Delete
Model::withTrashed()->where('cars', 2)->get();
// Include the soft deleted models in the results
Model::withTrashed()->where('cars', 2)->restore();
Model::where('cars', 2)->forceDelete();
// Force the result set to only included soft deletes
Model::onlyTrashed()->where('cars', 2)->get();
// One To One - User::phone()
return $this->hasOne('App\Phone', 'foreign_key', 'local_key');
// One To One - Phone::user(), The Inverse Of The Relation
return $this->belongsTo('App\User', 'foreign_key', 'other_key');

// One To Many - Post::comments()
return $this->hasMany('App\Comment', 'foreign_key', 'local_key');
//  One To Many - Comment::post()
return $this->belongsTo('App\Post', 'foreign_key', 'other_key');

// Many To Many - User::roles();
return $this->belongsToMany('App\Role', 'user_roles', 'user_id', 'role_id');
// Many To Many - Role::users();
return $this->belongsToMany('App\User');
// Many To Many - Retrieving Intermediate Table Columns
// Many To Many - Pivot table with extra attributes
return $this->belongsToMany('App\Role')->withPivot('column1', 'column2');
// Many To Many - Automatically maintained created_at and updated_at timestamps
return $this->belongsToMany('App\Role')->withTimestamps();

// Has Many Through - Country::posts(), A Country model have
// many Post models through an intermediate User model (User::country_id)
return $this->hasManyThrough('App\Post', 'App\User', 'country_id', 'user_id');

// Polymorphic Relations - Photo::imageable()
return $this->morphTo();
// Polymorphic Relations - Staff::photos()
return $this->morphMany('App\Photo', 'imageable');
// Polymorphic Relations - Product::photos()
return $this->morphMany('App\Photo', 'imageable');
// Polymorphic Relations - Register the morphMap in your AppServiceProvider
    'Post' => App\Post::class,
    'Comment' => App\Comment::class,

// Many To Many Polymorphic Relations - Tables: posts,videos,tags,taggables
// Post::tags()
return $this->morphToMany('App\Tag', 'taggable');
// Video::tags()
return $this->morphToMany('App\Tag', 'taggable');
// Tag::posts()
return $this->morphedByMany('App\Post', 'taggable');
// Tag::videos()
return $this->morphedByMany('App\Video', 'taggable');

// Querying Relations
$user->posts()->where('active', 1)->get();
// Retrieve all posts that have at least one comment...
$posts = App\Post::has('comments')->get();
// Retrieve all posts that have three or more comments...
$posts = Post::has('comments', '>=', 3)->get();
// Retrieve all posts that have at least one comment with votes...
$posts = Post::has('comments.votes')->get();
// Retrieve all posts with at least one comment containing words like foo%
$posts = Post::whereHas('comments', function ($query) {
    $query->where('content', 'like', 'foo%');

// Eager Loading
$books = App\Book::with('author')->get();
$books = App\Book::with('author', 'publisher')->get();
$books = App\Book::with('author.contacts')->get();

// Lazy Eager Loading
$books->load('author', 'publisher');

// Inserting Related Models
$comment = new App\Comment(['message' => 'A new comment.']);
// save multiple related models
    new App\Comment(['message' => 'A new comment.']),
    new App\Comment(['message' => 'Another comment.']),
$post->comments()->create(['message' => 'A new comment.']);

// Updating a belongsTo relationship

// Inserting Related Models - Many To Many Relationships
$user->roles()->attach($roleId, ['expires' => $expires]);
// Detach a single role from the user...
// Detach all roles from the user...
$user->roles()->detach([1, 2, 3]);
$user->roles()->attach([1 => ['expires' => $expires], 2, 3]);

// Any IDs that are not in the given array will be removed from the intermediate table.
$user->roles()->sync([1, 2, 3]);
// You may also pass additional intermediate table values with the IDs:
$user->roles()->sync([1 => ['expires' => true], 2, 3]);

Model::observe(new FooObserver);
Eloquent Configuration
// Disables mass assignment exceptions from being thrown from model inserts and updates
// Renables any ability to throw mass assignment exceptions


// Auto-Magic Pagination
Model::where('cars', 2)->paginate(15);
// "Next" and "Previous" only
Model::where('cars', 2)->simplePaginate(15);
// Manual Paginator
Paginator::make($items, $totalItems, $perPage);
// Print page navigators in view


Lang::get('messages.welcome', array('foo' => 'Bar'));
Lang::choice('messages.apples', 10);
// Lang::get alias


// Get a file's contents by requiring it
// Require the given file once
// Write the contents of a file
File::put('path', 'contents');
// Append to a file
File::append('path', 'data');
// Delete the file at a given path
// Move a file to a new location
File::move('path', 'target');
// Copy a file to a new location
File::copy('path', 'target');
// Extract the file extension from a file path
// Get the file type of a given file
// Get the file size of a given file
// Get the file's last modification time
// Determine if the given path is a directory
// Determine if the given path is writable
// Determine if the given path is a file
// Find path names matching a given pattern.
File::glob($patterns, $flag);
// Get an array of all files in a directory.
// Get all of the files from the given directory (recursive).
// Get all of the directories within a given directory.
// Create a directory
File::makeDirectory('path',  $mode = 0777, $recursive = false);
// Copy a directory from one location to another
File::copyDirectory('directory', 'destination', $options = null);
// Recursively delete a directory
File::deleteDirectory('directory', $preserve = false);
// Empty the specified directory of all files and folders


Install and run
// add to composer and update:
"phpunit/phpunit": "4.0.*"
// run tests (from project root)
$this->assertEquals('foo', $bar);
$this->assertViewHas('age', $value);
// Asserting the session has errors for a given key...
// Asserting the session has errors for several keys...
$this->assertSessionHasErrors(array('name', 'age'));
Calling routes
$response = $this->call($method, $uri, $parameters, $files, $server, $content);
$response = $this->callSecure('GET', 'foo/bar');
$this->session(['foo' => 'bar']);


Executing Commands
SSH::run(array $commands);
SSH::into($remote)->run(array $commands); // specify remote, otherwise assumes default
SSH::run(array $commands, function($line)
echo $line.PHP_EOL;
// define
SSH::define($taskName, array $commands);
// execute
SSH::task($taskName, function($line)
echo $line.PHP_EOL;
SFTP Uploads
SSH::put($localFile, $remotePath);
SSH::putString($string, $remotePath);


// Indicate that the table needs to be created
Schema::create('table', function($table)
// Specify a Connection
Schema::connection('foo')->create('table', function($table){});
// Rename the table to a given name
Schema::rename($from, $to);
// Indicate that the table should be dropped
// Indicate that the table should be dropped if it exists
// Determine if the given table exists
// Determine if the given table has a given column
Schema::hasColumn('table', 'column');
// Update an existing table
Schema::table('table', function($table){});
// Indicate that the given columns should be renamed
$table->renameColumn('from', 'to');
// Indicate that the given columns should be dropped
// The storage engine that should be used for the table
$table->engine = 'InnoDB';
// Only work on MySQL
// Creates a dual primary key
$table->primary(array('first', 'last'));
$table->unique('column', 'key_name');
// Creates a dual unique index
$table->unique(array('first', 'last'));
$table->unique(array('first', 'last'), 'key_name');
$table->index('column', 'key_name');
// Creates a dual index
$table->index(array('first', 'last'));
$table->index(array('first', 'last'), 'key_name');
Foreign Keys
$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade'|'restrict'|'set null'|'no action');
$table->foreign('user_id')->references('id')->on('users')->onUpdate('cascade'|'restrict'|'set null'|'no action');
Column Types
// Increments

// Numbers
$table->double('column', 15, 8);
$table->decimal('amount', 5, 2);

//String and Text
$table->char('name', 4);
$table->string('name', 100);

//Date and Time
// Adds created_at and updated_at columns

// Others
// Adds deleted_at column for soft deletes
$table->enum('choices', array('foo', 'bar'));
// Adds remember_token as VARCHAR(100) NULL
// Adds INTEGER parent_id and STRING parent_type


// Default if the key is missing
Input::get('key', 'default');
// Only retrieve 'foo' and 'bar' when getting input
Input::only('foo', 'bar');
// Disregard 'foo' when getting input
Session Input (flash)
// Flash input to the session
// Flash only some of the input to the session
Input::flashOnly('foo', 'bar');
// Flash only some of the input to the session
Input::flashExcept('foo', 'baz');
// Retrieve an old input item
// Use a file that's been uploaded
// Determine if a file was uploaded
// Access file properties
// Move an uploaded file
// Move an uploaded file
Input::file('name')->move($destinationPath, $fileName);


Cache::put('key', 'value', $minutes);
Cache::add('key', 'value', $minutes);
Cache::forever('key', 'value');
Cache::remember('key', $minutes, function(){ return 'value' });
Cache::rememberForever('key', function(){ return 'value' });
Cache::get('key', 'default');
Cache::get('key', function(){ return 'default'; });
Cache::tags('my-tag')->put('key','value', $minutes);
Cache::increment('key', $amount);
Cache::decrement('key', $amount);
Cache::section('group')->put('key', $value);


Cookie::get('key', 'default');
// Create a cookie that lasts for ever
Cookie::forever('key', 'value');
// Create a cookie that lasts N minutes
Cookie::make('key', 'value', 'minutes');
// Set a cookie before a response has been created
Cookie::queue('key', 'value', 'minutes');
// Forget cookie
// Send a cookie with a response
$response = Response::make('Hello World');
// Add a cookie to the response
$response->withCookie(Cookie::make('name', 'value', $minutes));


// Returns an item from the session
Session::get('key', 'default');
Session::get('key', function(){ return 'default'; });
// Get the session ID
// Put a key / value pair in the session
Session::put('key', 'value');
// Push a value into an array in the session
// Returns all items from the session
// Checks if an item is defined
// Remove an item from the session
// Remove all of the items from the session
// Generate a new session identifier
// Flash a key / value pair to the session
Session::flash('key', 'value');
// Reflash all of the session flash data
// Reflash a subset of the current flash data
Session::keep(array('key1', 'key2'));


// url: http://xx.com/aa/bb
// path: /aa/bb
// getRequestUri: /aa/bb/?c=d
// Returns user's IP
// getUri: http://xx.com/aa/bb/?c=d
// getQueryString: c=d
// Get the port scheme of the request (e.g., 80, 443, etc.)
// Determine if the current request URI matches a pattern
// Get a segment from the URI (1 based index)
// Retrieve a header from the request
// Retrieve a server variable from the request
// Determine if the request is the result of an AJAX call
// Determine if the request is over HTTPS
// Get the request method
// Checks if the request method is of specified type
// Get raw POST data
// Get requested response format
// true if HTTP Content-Type header contains */json
// true if HTTP Accept header is application/json



return Response::make($contents);
return Response::make($contents, 200);
return Response::json(array('key' => 'value'));
return Response::json(array('key' => 'value'))
return Response::download($filepath);
return Response::download($filepath, $filename, $headers);
// Create a response and modify a header value
$response = Response::make($contents, 200);
$response->header('Content-Type', 'application/json');
return $response;
// Attach a cookie to a response
return Response::make($content)
->withCookie(Cookie::make('key', 'value'));


return Redirect::to('foo/bar');
return Redirect::to('foo/bar')->with('key', 'value');
return Redirect::to('foo/bar')->withInput(Input::get());
return Redirect::to('foo/bar')->withInput(Input::except('password'));
return Redirect::to('foo/bar')->withErrors($validator);
// Create a new redirect response to the previous location
return Redirect::back();
// Create a new redirect response to a named route
return Redirect::route('foobar');
return Redirect::route('foobar', array('value'));
return Redirect::route('foobar', array('key' => 'value'));
// Create a new redirect response to a controller action
return Redirect::action('FooController@index');
return Redirect::action('FooController@baz', array('value'));
return Redirect::action('FooController@baz', array('key' => 'value'));
// If intended redirect is not defined, defaults to foo/bar.
return Redirect::intended('foo/bar');


App::bind('foo', function($app){ return new Foo; });
// If this class exists, it's returned
// Register a shared binding in the container
App::singleton('foo', function(){ return new Foo; });
// Register an existing instance as shared in the container
App::instance('foo', new Foo);
// Register a binding with the container
App::bind('FooRepositoryInterface', 'BarRepository');
// Register a service provider with the application
// Listen for object resolution


Hash::check('secretpassword', $hashedPassword);


// Determine if the current user is authenticated
// Get the currently authenticated user
// Get the ID of the currently authenticated user
// Attempt to authenticate a user using the given credentials
Auth::attempt(array('email' => $email, 'password' => $password));
// 'Remember me' by passing true to Auth::attempt()
Auth::attempt($credentials, true);
// Log in for a single request
// Log a user into the application
// Log the given user ID into the application
// Log the user out of the application
// Validate a user's credentials
// Attempt to authenticate using HTTP Basic Auth
// Perform a stateless HTTP Basic login attempt
// Send a password reminder to a user
Password::remind($credentials, function($message, $user){});
// Define abilities
Gate::define('update-post', 'Class@method');
Gate::define('update-post', function ($user, $post) {...});
// Passing multiple argument
Gate::define('delete-comment', function ($user, $post, $comment) {});

// Check abilities
Gate::denies('update-post', $post);
Gate::allows('update-post', $post);
Gate::check('update-post', $post);
// Specified a user for checking
Gate::forUser($user)->allows('update-post', $post);
// Through User model, using Authorizable trait
User::find(1)->can('update-post', $post);
User::find(1)->cannot('update-post', $post);

// Intercepting Authorization Checks
Gate::before(function ($user, $ability) {});
Gate::after(function ($user, $ability) {});

// Chekcing in Blade template
@can('update-post', $post)
// with else
@can('update-post', $post)

// Generate a Policy
php artisan make:policy PostPolicy
// `policy` helper function
policy($post)->update($user, $post)

// Controller Authorization
$this->authorize('update', $post);
// for $user
$this->authorizeForUser($user, 'update', $post);



Mail::send('email.view', $data, function($message){});
Mail::send(array('html.view', 'text.view'), $data, $callback);
Mail::queue('email.view', $data, function($message){});
Mail::queueOn('queue-name', 'email.view', $data, $callback);
Mail::later(5, 'email.view', $data, function($message){});
// Write all email to logs instead of sending
// These can be used on the $message instance passed into Mail::send() or Mail::queue()
$message->from('email@example.com', 'Mr. Example');
$message->sender('email@example.com', 'Mr. Example');
$message->to('email@example.com', 'Mr. Example');
$message->cc('email@example.com', 'Mr. Example');
$message->bcc('email@example.com', 'Mr. Example');
$message->replyTo('email@example.com', 'Mr. Example');
$message->subject('Welcome to the Jungle');
$message->attach('foo\bar.txt', $options);
// This uses in-memory data as attachments
$message->attachData('bar', 'Data Name', $options);
// Embed a file in the message and get the CID
$message->embedData('foo', 'Data Name', $options);
// Get the underlying Swift Message instance


Queue::push('SendMail', array('message' => $message));
Queue::push('SendEmail@send', array('message' => $message));
Queue::push(function($job) use $id {});
// Same payload to multiple workers
Queue::bulk(array('SendEmail', 'NotifyUser'), $payload);
// Starting the queue listener
php artisan queue:listen
php artisan queue:listen connection
php artisan queue:listen --timeout=60
// Process only the first job on the queue
php artisan queue:work
// Start a queue worker in daemon mode
php artisan queue:work --daemon
// Create migration file for failed jobs
php artisan queue:failed-table
// Listing failed jobs
php artisan queue:failed
// Delete failed job by id
php artisan queue:forget 5
// Delete all failed jobs
php artisan queue:flush


array('key' => 'Foo'),
array('key' => 'required|in:Foo')
Validator::extend('foo', function($attribute, $value, $params){});
Validator::extend('foo', 'FooValidator@validate');
Validator::resolver(function($translator, $data, $rules, $msgs)
return new FooValidator($translator, $data, $rules, $msgs);



View::make('foo/bar')->with('key', 'value');
View::make('foo/bar', array('key' => 'value'));
// Share a value across all views
View::share('key', 'value');
// Nesting views
View::make('foo/bar')->nest('name', 'foo/baz', $data);
// Register a view composer
View::composer('viewname', function($view){});
//Register multiple views to a composer
View::composer(array('view1', 'view2'), function($view){});
// Register a composer class
View::composer('viewname', 'FooComposer');
View::creator('viewname', function($view){});


// Show a section in a template
// Begin a section
// End a section
// End a section and yield

@include('view.name', array('key' => 'value'));
@choice('messages.name', 1);






//forelse 4.2 feature
@forelse($users as $user)

// Echo content
{{ $var }}
// Echo escaped content
{{{ $var }}}
// Echo unescaped content; 5.0 feature
{!! $var !!}
{{-- Blade Comment --}}
// Echoing Data After Checking For Existence
{{{ $name or 'Default' }}}
// Displaying Raw Text With Curly Braces
@{{ This will not be processed by Blade }}


Form::open(array('url' => 'foo/bar', 'method' => 'PUT'));
Form::open(array('route' => 'foo.bar'));
Form::open(array('route' => array('foo.bar', $parameter)));
Form::open(array('action' => 'FooController@method'));
Form::open(array('action' => array('FooController@method', $parameter)));
Form::open(array('url' => 'foo/bar', 'files' => true));
Form::model($foo, array('route' => array('foo.bar', $foo->bar)));

Form Elements
Form::label('id', 'Description');
Form::label('id', 'Description', array('class' => 'foo'));
Form::text('name', $value);
Form::text('name', $value, array('class' => 'name'));
Form::textarea('name', $value);
Form::textarea('name', $value, array('class' => 'name'));
Form::hidden('foo', $value);
Form::password('password', array('placeholder' => 'Password'));
Form::email('name', $value, array());
Form::file('name', array('class' => 'name'));
Form::checkbox('name', 'value');
// Generating a checkbox that is checked
Form::checkbox('name', 'value', true, array('class' => 'name'));
Form::radio('name', 'value');
// Generating a radio input that is selected
Form::radio('name', 'value', true, array('class' => 'name'));
Form::select('name', array('key' => 'value'));
Form::select('name', array('key' => 'value'), 'key', array('class' => 'name'));
Form::selectRange('range', 1, 10);
Form::selectYear('year', 2011, 2015);
Form::submit('Submit!', array('class' => 'name'));
Form::button('name', array('class' => 'name'));
Form::macro('fooField', function()
return '<input type="custom"/>';


HTML::macro('name', function(){});
// Convert an HTML string to entities
// Convert entities to HTML characters
// Generate a link to a JavaScript file
HTML::script($url, $attributes);
// Generate a link to a CSS file
HTML::style($url, $attributes);
// Generate an HTML image element
HTML::image($url, $alt, $attributes);
// Generate a HTML link
HTML::link($url, 'title', $attributes, $secure);
// Generate a HTTPS HTML link
HTML::secureLink($url, 'title', $attributes);
// Generate a HTML link to an asset
HTML::linkAsset($url, 'title', $attributes, $secure);
// Generate a HTTPS HTML link to an asset
HTML::linkSecureAsset($url, 'title', $attributes);
// Generate a HTML link to a named route
HTML::linkRoute($name, 'title', $parameters, $attributes);
// Generate a HTML link to a controller action
HTML::linkAction($action, 'title', $parameters, $attributes);
// Generate a HTML link to an email address
HTML::mailto($email, 'title', $attributes);
// Obfuscate an e-mail address to prevent spam-bots from sniffing it
// Generate an ordered list of items
HTML::ol($list, $attributes);
// Generate an un-ordered list of items
HTML::ul($list, $attributes);
// Create a listing HTML element
HTML::listing($type, $list, $attributes);
// Create the HTML for a listing element
HTML::listingElement($key, $type, $value);
// Create the HTML for a nested listing attribute
HTML::nestedListing($key, $type, $value);
// Build an HTML attribute string from an array
// Build a single attribute element
HTML::attributeElement($key, $value);
// Obfuscate a string to prevent spam-bots from sniffing it


// Transliterate a UTF-8 value to ASCII
Str::contains($haystack, $needle)
Str::endsWith($haystack, $needles)
// Cap a string with a single instance of a given value.
Str::finish($value, $cap)
Str::is($pattern, $value)
Str::limit($value, $limit = 100, $end = '...')
Str::words($value, $words = 100, $end = '...')
Str::plural($value, $count = 2)
// Generate a more truly "random" alpha-numeric string.
Str::random($length = 16)
// Generate a "random" alpha-numeric string.
Str::quickRandom($length = 16)
Str::slug($title, $separator = '-')
Str::snake($value, $delimiter = '_')
Str::startsWith($haystack, $needles)
// Convert a value to studly caps case.
Str::macro($name, $macro)


// adds a given key / value pair to the array if the
// given key doesn't already exist in the array
array_add($array, 'key', 'value');
// collapse an array of arrays into a single array
// Divide an array into two arrays. One with keys and the other with values
// Flatten a multi-dimensional associative array with dots
// Get all of the given array except for a specified array of items
array_except($array, array('key'));
// Return the first element in an array passing a given truth test
array_first($array, function($key, $value){}, $default);
// Strips keys from the array
// Remove one or many array items from a given array using "dot" notation
array_forget($array, 'foo');
// Dot notation
array_forget($array, 'foo.bar');
// Get an item from an array using "dot" notation
array_get($array, 'foo', 'default');
array_get($array, 'foo.bar', 'default');
// Checks that a given item exists in an array using "dot" notation
array_has($array, 'products.desk');
// Get a subset of the items from the given array
array_only($array, array('key'));
// Return array of key => values
array_pluck($array, 'key');
// Return and remove 'key' from array
array_pull($array, 'key');
// Set an array item to a given value using "dot" notation
array_set($array, 'key', 'value');
// Dot notation
array_set($array, 'key.subkey', 'value');
// Sorts the array by the results of the given Closure
array_sort($array, function(){});
// Recursively sorts the array using the sort function
// Filters the array using the given Closure
// First element of an array
// Last element of an array
// Fully qualified path to the app directory
// Get the path to the public folder
// Fully qualified path to the application configuration directory
// Fully qualified path to the application's database directory
// Gets the path to the versioned Elixir file:
// Fully qualified path to the public directory
// Get the path to the storage folder
// Convert a value to camel case
// Get the class "basename" of the given object / class
// Escape a string
// Determine if a given string starts with a given substring
starts_with('Foo bar.', 'Foo');
// Determine if a given string ends with a given substring
ends_with('Foo bar.', 'bar.');
// Convert a string to snake case
// Limits the number of characters in a string
// Determine if a given string contains a given substring
str_contains('Hello foo bar.', 'foo');
// Result: foo/bar/
str_finish('foo/bar', '/');
str_is('foo*', 'foobar');
str_slug("Laravel 5 Framework", "-");
// Result: FooBar
trans_choice('foo.bar', $count);
URLs and Links
action('FooController@method', $parameters);
// HTML Link
asset('img/photo.jpg', $title, $attributes);
// HTTPS link
secure_asset('img/photo.jpg', $title, $attributes);
route($route, $parameters, $absolute = true);
url('path', $parameters = array(), $secure = null);
// Authenticator instance (Auth)
// Generates a redirect response to the user's previous location
// Hashes the given value using Bcrypt (Hash)
// Creates a collection instance from the supplied items
collect(['taylor', 'abigail']);
// Gets the value of a configuration variable
config('app.timezone', $default);
// Generates an HTML hidden input field containing the value of the CSRF token
{!! csrf_field() !!}
// Retrieves the value of the current CSRF token
$token = csrf_token();
// Dumps the given variable and ends execution of the script
// Gets the value of an environment variable or returns a default value
$env = env('APP_ENV');
$env = env('APP_ENV', 'production');
// Dispatches the given event to its listeners:
event(new UserRegistered($user));
// Creates a model factory builder for a given class
$user = factory(App\User::class)->make();
// Generates an HTML hidden input field containing the spoofed value of the form's HTTP verb
{!! method_field('delete') !!}
// Retrieves an old input value flashed into the session
$value = old('value');
$value = old('value', 'default');
// Returns an instance of the redirector to do redirects:
return redirect('/home');
// Returns the current request instance or obtains an input item
$value = request('key', $default = null)
// Creates a response instance or obtains an instance of the response factory
return response('Hello World', 200, $headers);
// Used to get / set a session value
$value = session('key');
$value = session()->get('key');
session()->put('key', $value);
// Will simply return the value it is given.
value(function(){ return 'bar'; });
// Retrieves a view instance
return view('auth.login');
// Returns the value it is given
$value = with(new Foo)->work();


// Creating Collections
collect([1, 2, 3]);
// Simply returns the underlying array represented by the collection:
// Returns the average of all items in the collection:
// Breaks the collection into multiple, smaller collections of a given size:
// Collapses a collection of arrays into a flat collection:
// Determines whether the collection contains a given item:
$collection->contains('New York');
// Returns the total number of items in the collection:
// Iterates over the items in the collection and passes each item to a given callback:
$collection = $collection->each(function ($item, $key) {
// Creates a new collection consisting of every n-th element:
// Pass offset as the second argument:
$collection->every(4, 1);
// Returns all items in the collection except for those with the specified keys:
$collection->except(['price', 'discount']);
// Filters the collection by a given callback:
$filtered = $collection->filter(function ($item) {
    return $item > 2;
// Returns the first element in the collection that passes a given truth test:
collect([1, 2, 3, 4])->first(function ($key, $value) {
    return $value > 2;
// Flattens a multi-dimensional collection into a single dimension:
$flattened = $collection->flatten();
// Swaps the collection's keys with their corresponding values:
$flipped = $collection->flip();
// Removes an item from the collection by its key:
// Returns a new collection containing the items:
$chunk = $collection->forPage(2, 3);
// Returns the item at a given key. If the key does not exist, null is returned:
$value = $collection->get('name');
// Groups the collection's items by a given key:
$grouped = $collection->groupBy('account_id');
// Determines if a given key exists in the collection:
// Joins the items in a collection:
$collection->implode('product', ', ');
// Removes any values that are not present in the given array or collection:
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
// Returns true if the collection is empty:
// Keys the collection by the given key:
$keyed = $collection->keyBy('product_id');
// Pass a callback, which should return the value to key the collection by:
$keyed = $collection->keyBy(function ($item) {
    return strtoupper($item['product_id']);
// Returns all of the collection's keys:
$keys = $collection->keys();
// Returns the last element in the collection:
// Iterates through the collection and passes each value to the given callback:
$multiplied = $collection->map(function ($item, $key) {
    return $item * 2;
// Return the maximum value of a given key:
$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
$max = collect([1, 2, 3, 4, 5])->max();
// Merges the given array into the collection:
$merged = $collection->merge(['price' => 100, 'discount' => false]);
// Return the minimum value of a given key:
$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
$min = collect([1, 2, 3, 4, 5])->min();
// Returns the items in the collection with the specified keys:
$filtered = $collection->only(['product_id', 'name']);
// Retrieves all of the collection values for a given key:
$plucked = $collection->pluck('name');
// Removes and returns the last item from the collection:
// Adds an item to the beginning of the collection:
// Pass a second argument to set the key of the prepended item:
$collection->prepend(0, 'zero');
// Removes and returns an item from the collection by its key:
// Appends an item to the end of the collection:
// Sets the given key and value in the collection:
$collection->put('price', 100);
// Returns a random item from the collection:
// Pass an integer to random. If that integer is more than 1, a collection of items is returned:
$random = $collection->random(3);
// Reduces the collection to a single value:
$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
// Filters the collection using the given callback:
$filtered = $collection->reject(function ($item) {
    return $item > 2;
// Reverses the order of the collection's items:
$reversed = $collection->reverse();
// Searches the collection for the given value and returns its key if found:
// Removes and returns the first item from the collection:
// Randomly shuffles the items in the collection:
$shuffled = $collection->shuffle();
// Returns a slice of the collection starting at the given index:
$slice = $collection->slice(4);
// Sorts the collection:
$sorted = $collection->sort();
// Sorts the collection by the given key:
$sorted = $collection->sortBy('price');
// Removes and returns a slice of items starting at the specified index:
$chunk = $collection->splice(2);
// Returns the sum of all items in the collection:
collect([1, 2, 3, 4, 5])->sum();
// Returns a new collection with the specified number of items:
$chunk = $collection->take(3);
// Converts the collection into a plain PHP array:
// Converts the collection into JSON:
// Iterates over the collection:
$collection->transform(function ($item, $key) {
    return $item * 2;
// Returns all of the unique items in the collection:
$unique = $collection->unique();
// Returns a new collection with the keys reset to consecutive integers:
$values = $collection->values();
// Filters the collection by a given key / value pair:
$filtered = $collection->where('price', 100);
// Merges together the values of the given array with the values of the collection:
$zipped = $collection->zip([100, 200]);

referensi : https://summerblue.github.io


[tutorial] Install XAMPP untuk Local Server pada Windows

Pada kesempatan ini kita akan melakukan instalasi web server dan database server mysql yang di bundling dalam XAMPP. berikut langkah-langkahnya

  1. Download XAMPP dari https://www.apachefriends.org
  2. Install XAMPP
  3. Konfigurasi XAMPP

Mari kita jabarkan tiap poinnya

1. Download XAMPP

Silahkan pilih versi yang akan di download. Pastikan bahwa versi yang dipilih mendukung aplikasi yang akan kita bangun. Selain itu sesuaikan juga OS yang digunakan. Dalam tutorial ini kita install di OS windows. Kali ini kita pilih download versi 7.2.17


tunggu sampai download selesai. Jika sudah jalankan file tersebut untuk mulai proses instalasi.

2. Instalasi XAMPP

Jalankan file tersebut dengan doublie klik atau tekan enter.


Pilih lokasi directory tempat file-file akan di install. Misal kita pilih D:\xampp
klik next > next > finish. Selanjutnya jalankan file

3. Konfigurasi

Konfigurasi ini tergantung keperluan



[tutorial] BAB 1 Persiapan CRUD pada Framework Laravel dan VueJS

crud laravel vuejs


Setelah kita mulai mempelajari suatu bahasa pemrograman tentang konsep, fundamental dan basic nya maka saatnya kita praktek lebih dalam praktek teknis pembuatan aplikasi yang sederhana. Suatu aplikasi hampir dipastikan ada aksi-aksi seperti

  • Create – menambah data
  • Read – membaca dan menampilkan data
  • Update – meng-edit dan update data
  • Delete – menghapus data

Aksi-aksi tersebut sering dan sudah biasa disebut dengan CRUD. Namun kali ini kita akan belajar praktek dari 0 (from scratch) membuat CRUD plus dengan Search, Pagination dan Report (laporan).

Teknologi yang akan kita pelajari dan praktekan diantaranya adalah

  • Xampp – Bundling Web server (apache2), DB server (Mysql) di local komputer kita
  • Composer – package manager
  • Framework Laravel – easily and quickly PHP framework based on MVC design pattern
  • Blade Template Engine – default bawaan laravel
  • Mysql Database – database sejuta umat
  • Framework VueJS – framework JS
  • Vue Router – agar vueJS lebih mudah
  • Axios – untuk menghadle http request
  • Ajax Request – agar http request lebih nyaman dan cepat
  • Html Form, table dll – view html

Kita asumsikan OS yang dipakai adalah windows. Pada tahap persiapan ini yang perlu kita lakukan diantaranya adalah

  1. Instalasi Xampp
  2. Instalasi Composer
  3. Instalasi Laravel
  4. Integrasi VueJS
  5. Menyusun relasi database

karena kita mau menggunakan laravel maka kita perlu ketahui dulu requirement dari versi laravel yang akan kita install. Kita akan menggunakan laravel versi 5.7.
Update fitur laravel versi 5.7 diantaranya

  • Securing Laravel APIs with Auth0
  • Laravel Dump Server Integration
  • Laravel Nova
  • Guest User Gates / Policies
  • Email Verification
  • Optional Email Verification
  • URL Generator & Callable Syntax
  • Paginator
  • Improved Error Messages
  • Testing Artisan Commands

kemudian requirement untuk laravel 5.7 adalah

  • PHP >= 7.1.3
  • OpenSSL PHP Extension
  • PDO PHP Extension
  • Mbstring PHP Extension
  • Tokenizer PHP Extension
  • XML PHP Extension
  • Ctype PHP Extension
  • JSON PHP Extension
  • BCMath PHP Extension

1. Instalasi XAMPP

Setelah kita mengetahui requirement Laravel maka kita perlu memilih versi Xampp yang mendukung requirement tersebut. Kita pilih xampp versi 7.2.17.
untuk detail tahap ini kita lanjutkan di sub bab berikutnya yakni installasi xampp di link ini

[solved] composer Content-Length mismatch

composer Content Length mismatch

 How to solve composer Content-Length mismatch error

Content-Length mismatch, received 573177 bytes out of the expected 761373
https://repo.packagist.org could not be fully loaded, package information was loaded from the local cache and may be out of date
Your requirements could not be resolved to an installable set of packages.

Just change the composer default repo url:

composer config -g repo.packagist composer https://packagist.org
composer config -g github-protocols https ssh

It changes or sets the packagist repo to be used by https only.

see other post @ qodrbee

[compare] Perbedaan dan perbandingan WebSocket vs Socket.io

WebSocket vs socket.io

Apa perbedaan websocket dengan socket.io

Oke pertama kita bahas dulu tentang websocket.
Websocket adalah Protokol komunikasi yang menyediakan komunikasi dua arah antara Klien dan Server melalui koneksi TCP, WebSocket selalu open sepanjang waktu sehingga mereka memungkinkan transfer data real-time.
Ketika klien melakukan request ke Server, koneksi tidak tertutup (closed) saat response diterima, koneksi akan tetap open sampai klien atau server mengakhiri request.

Poin penting pada websocket diantaranya

  • WebSocket membantu komunikasi realtime antara client dan web server.
  • WebSocket membantu komunikasi cross-platform antara client dan web server.
  • WebSocket membantu kebutuhan bisnis di seluruh dunia untuk realtime web aplikasi.
  • WebSocket membantu koneksi pada HTTP dalam komunikasi full duplex
  • WebSocket menghilangkan overhead and mengurangi complexity.
  • WebSocket membuat komunikasi real-time lebih mudah dan efisien.

Skema Protokol WebSocket :

WebSocket vs socket.io

Selanjutnya kita lihat tentang Socket.io
Socket.io adalah library yang memungkinkan komunikasi real-time dan full dupleks antara Klien dan server Web. Ia menggunakan protokol WebSocket sebagai interface nya. Secara umum socket.io dibagi menjadi dua bagian yakni sisi client berupa library yang berjalan di browser dan sisi server berjalan di web server.

Poin penting pada socket.io diantaranya

  • Socket.io dapat melakukan broadcast ke beberapa socket sekaligus dan dapat menangani koneksi secara transparan.
  • Socket.io bekerja di semua platform, server atau device dan meningkatkan kualitas, keandalan, dan kecepatan.
  • Secara otomatis meningkatkan requirement ke WebSocket jika diperlukan.
  • Socket.io mengimplementasikan real-time transport protocol real-time secara custom dibanding protokol lainnya.
  • Socket.io membutuhkan dua library untuk digunakan sisi Klien dan library sisi server.
  • Socket.io berjalan dengan work-based event. ada beberapa event khusus yang dapat diakses menggunakan Socket di sisi server seperti Connect, message, Disconnect, Ping dan Reconnect.
  • Ada beberapa event yang dijalankan khusus oleh Klien seperti Connect, connect- error, connect-timeout and Reconnect
  • Secara teknis Socket.io menangani komunikasi full dupleks secara real time.
  • Socket.io juga menangani ketidakkonsistenan dari browser.
  • Socket.io juga memberikan dukungan fitur tambahan untuk infrastruktur publikasi dasar dan melakukan reconnect secara otomatis.
  • Saat ini, AFAIK adalah yang paling sering digunakan dan lebih mudah untuk membantu dalam pengembangan vanilla web soket.

Websocket VS Socket.io

mari kita lihat perbedaan nya dalam table perbandingan

1protocol yang tebangun pada koneksi TCPlibrary untuk berjalan dengan WebSocket
2full duplex communication pada koneksi TCPkomunikasi event-based antara browser dan server.
3Proxy dan load balancer tidak didukung di WebSocket.koneksi dapat terbangun walaupun lewat proxi and load balancer.
4.tidak support broadcasting.supports broadcasting.
5.tidak punya a fallback option.supports fallback options.

Kesimpulan nya

Untuk kebutuhan realtime communication socket.io melengkapi websocket dalam praktek pengembangan aplikasinya. Untuk lebih jelasnya silahkan praktekan secara teknis penggunaannya.

referensi : https://educba.com

[solved] Bagaimana cek element html visible di screen dengan jQuery

Check Visibility element viewport or Checking if an element is visible on-screen using jQuery

How to Check an Element is Visible or not Using jQuery?

untuk dapat mengecek apakah element terlihat di layar atau tidak bisa menggunakan jQuery library Element Onscreen Visibility dari om Matthew yang dapat anda download di sini.
ingat ini ngecek apakah muncul di layar saat ini, bukan yang tidak muncul di layar… semisal page nya panjang ke bawah dan ada yang tertutupi maka element yg tertutupi di bawah akan bernilai false.

how to use

result akan bernilai true jika element visible (kelihatan) oleh mata user.


result akan bernilai true jika bagian dari element visible (kelihatan) oleh mata user.

$('#element').visible( true );

Secara default plugin ini akan mengabaikan element dengan css seperti , display:none, visibility: hidden, offsetWidth or offsetHeight is 0 . untuk memfilter css visibility, Anda bisa gunakan  jQuery :visible selector


Sebagai tambahan, anda bisa meanmbah parameter ke dua  yang akan memeriksa apakah elemen visible, serta apakah itu ada dalam viewport (pandangan user) juga.

$('#element:visible').visible( false, true );

Tambahan lagi.. Anda bisa menambah parameter ke tiga untuk menentukan arah ketika memeriksa visibilitas. bisa ‘horisontal’, ‘vertikal atau both. Secara default both.

$('#element').visible( false, false, 'horizontal' );

supaya lebih paham silahkan lihat demo ini. check visibility element viewport
lihat juga demo implementasi yang ada di qodrbee pada bagian daftar isi

[tutorial] Cara Mengirim Isi Form ke Whatsapp

Selama ini kita sudah ketahui bersama bahwa mengirim pesan WA dapat lewat web atau lewat URL. Lebih tepat nya lewat http://api.whatsapp.com/send?phone=628975835238&text=Assalamualaikum%20mas%20usman .
Namun cara ini punya banyak keterbatasan, diantaranya…

  1. hanya bisa jalan jika menggunakan google chrome
  2. bagaimana kalo yang dikirim text nya dari suatu form
  3. loading yang cukup lama ketika mau mengirim pesan di api.whatsapp.com

Nah kali ini saya akan membeberkan rahasia dahsyat cara mengirim pesan whatsapp lewat form secara instan tanpa coding… serius tanpa coding. Saya jamin tanpa coding… kalau sampai coding Anda boleh datengi rumah saya (sambil bawa oleh2) untuk komplain… haha

oke kembali ke laptop… jadi ceritanya kita punya form lalu ingin agar auto sent ke WA isi form tersebut. Caranya cukup mudah… anda hanya perlu :

  1. install plugin wordpress woowa dari http://woo-wa.com
  2. buat form
  3. setting plugin
  4. submit form

oke kita jabarkan

1. Install plugin woowa

pastikan web anda menggunakan wordpress jika bukan maka skip sampe bawah lalu klik share. kemudian kunjungi https://woo-wa.com untuk mendapatkan plugin woowa. Anda juga dapat mencoba berbagai demo disana.

woowa whtasapp gateway notifier api

Setelah mendaftar dan dapat akun sebagai member. Login masuk ke member area dan klik menu DOWNLOAD & UPDATE dan klik download.zip

woowa download page

Setelah di download install plugin tersebut di menu plugins > Add New klik Upload Plugin lalu Browse

Setelah itu active plugin itu di menu installed plugins dengan cara klik active. Oke sekarang plugin sudah berhasil active. selanjutnya kita perlu untuk setting konfigurasi agar dapat kita gunakan.

untuk selanjutnya akan kita setting plugin ini pada step 3. sebelum itu kita bikin dulu form yang akan kita gunakan untuk kirim ke WA.

2. Membuat Form

untuk membuat form dapat dilakukan dengan berbagai macam cara. Diantaranya dengan memakai plugin Contact Form 7 (CF7), elementor atau caldera Form dan lain nya. Kita coba dengan CF7. pertama install lewat plugins > add new . Search plugin Contact Form 7 lalu install dan activate.

contact form 7 install plugin

lalu klik menu Contact > add new dan buat form sesukamu.

PENTING!! jangan lupa tambahkan field no telp atau semisalnya agar di kirim ke nomor tujuan dan tombol submit tentunya. Kalau sudah klik save maka akan muncul shortcode. Contoh nya seperti ini
[contacts-form-7 id="296" title="Test Send WA via Woowa" html_id="contact-form-1234"] lalu copas. o iya saya tambahkan html_id="contact-form-1234" (khusus cf7) agar form nya ada id nya. karena id ini wajib ada untuk deteksi di plugin woowa. Bagi yang memakai selain cf 7 silahkan disesuaikan.

paste shortcode tadi di page. Klik pages > Add New lalu paste di textarea dan kasih judul form. Jika sudah maka save.

Lalu untuk lihat hasil nya klik View Page . Berikut contoh form yang berhasil dibuat dengan url yang terbentuk adalah http://qodrbee.com/online/test-form-send-wa-via-woowa/. Url ini akan kita pakai ketika setting nanti.

Oke form sudah jadi maka kita lanjutkan agar form ini terintegrasi dengan woowa, sehingga ketika di submit pesan akan terkirim ke Whatsapp.

3.Setting Plugin

Setelah mendapat license dari woo-wa.com masuk ke dashboard my.woo-wa.com untuk link WA Anda ke woo-wa sehingga terkoneksi. Setelah berhasil login di dashboard my.woo-wa.com klik add domain untuk menambah domain anda dan kli link WA untuk mengkoneksikan WA anda dengan woowa.

ketika link akan muncul popup untuk scan qr code, tunggu sampai qr code ter-load. setelah itu scan qr code menggunakan hp Anda yg terinstall whatsapp. klik pojok kanan atas pada aplikasi whatsapp pilih web whatsapp. jika masih bingung lihat video yg ada di samping qrcode pada popup.

Jika sudah scan qr code pastikan bahwa status link WA anda authenticated caranya klik more pilih check dan tunggu sampai statusnya keluar.

ada juga fungsi lain di pilihan more yg bisa anda coba-coba. seperti screnshot untuk melihat layar status WA Anda. Oke selanjutnya setting pada plugin woowa pada wordpress.

Pertama pastikan plugin woowa sudah terinstall. Jika belum lihat step 1
lalu klik menu Woowa Premium > woocommerce klik tab license lalu masukan license yang di dapat dari woo-wa.com

setelah activated license maka anda bisa menggunakan plugin ini. Untuk keperluan send form to WA pilih menu Custom Form lalu klik Add Custom Form masukan judul/ title form nya, terserah saja. Lalu klik Add Form, akan muncul accordion template form, pada sebelah kanan switch on untuk mengaktifkan template.

selanjutnya masukan url form yang tadi (step 2) sudah kita bikin. Url tadi misalnya http://qodrbee.com/online/test-form-send-wa-via-woowa/ lalu klik scan

setelah scan form by url akan di dapat data-data field name dan id. Masukkan form id dan phone number field seperti gambar. Anda juga bisa menyusun kalimat yang dirangkai dengan memakai field yang tersedia. Jika sudah klik save.

4. Submit Form

buka form dan isi field nya lalu submit

Setelah di submit cek WA seharusnya ada yang masuk seperti ini

selamat anda telah berhasil mengirim pesan dari form ke Whatsapp secara instan.

5. Ringkasan

untuk mengirim WA ini diperlukan

  • form yang ada id, field no telp dan tombol submit
  • form dapat dibuat dengan apa saja yang penting syarat di atas terpenuhi
  • form tidak di generate oleh ajax/javascript tp murni html css
  • scan url form dengan plugin woowa untuk mendapatkan id dan name field
  • buat template sesuai kebutuhan dan isi form id dan field name no hp
  • pastikan whatsapp Anda sudah terkoneksi dengan woowa.com


6. Demo

Demo : http://qodrbee.com/online/test-form-send-wa-via-woowa/

7. Konsultasi

Feel free to ask me at ztoro.code@gmail.com
or WA 08975835238
or Telegram @ztorocode

How to Native Image Lazy Loading for Web

Native Lazy Loading Image for Web

native lazyload image for web

yess… native lazy load image for web. coba lihat script di atas… ada attribut loading pada tag img. Selama ini kita kalo mau melakukan lazy loading kita pake plugin kan? jQuery kan? … nah ini nih ada cara native loh…
dan ini berlaku untuk tag img dan iframe.

loading attribute ini akan bekerja ketika halaman di scroll ke img atau frame yang memakai loading ini. loading support 3 value :

  1. lazy: ini untuk lazy loading.
  2. eager: load langsung.
  3. auto: browser yang akan menentukan lazy load atau tidak.

jika tidak ada attribute loading maka dianggap auto. Berikut adalah contoh script nya..

<!-- Lazy-load an offscreen image when the user scrolls near it -->
<img src="unicorn.jpg" loading="lazy" alt=".."/>

<!-- Load an image right away instead of lazy-loading -->
<img src="unicorn.jpg" loading="eager" alt=".."/>

<!-- Browser decides whether or not to lazy-load the image -->
<img src="unicorn.jpg" loading="auto" alt=".."/>

<!-- Lazy-load images in <picture>. <img> is the one driving image 
loading so <picture> and srcset fall off of that -->
  <source media="(min-width: 40em)" srcset="big.jpg 1x, big-hd.jpg 2x">
  <source srcset="small.jpg 1x, small-hd.jpg 2x">
  <img src="fallback.jpg" loading="lazy">

<!-- Lazy-load an image that has srcset specified -->
<img src="small.jpg"
     srcset="large.jpg 1024w, medium.jpg 640w, small.jpg 320w"
     sizes="(min-width: 36em) 33.3vw, 100vw"
     alt="A rad wolf" loading="lazy">

<!-- Lazy-load an offscreen iframe when the user scrolls near it -->
<iframe src="video-player.html" loading="lazy"></iframe>

dan tahukan saudara-saudara bahwa fitur ini direncanakan akan support di chrome 75. itu kata bang Addy Osmani sebagai Engineering Manager at Google working on Chrome. Jadi sabar saja ya… tunggu tanggal main nya di qodrbee ya. cheers… ;p

referensi  https://addyosmani.com/blog/lazy-loading/