Kategori: LARAVEL

Bu yazımızda gelin Laravel’deki Component konusuna  bir bakalım.
Laravel’de Blade üzerinde sık tekrarladığımız şeyler olur.
Örneğin tüm CRUD işlemlerinde, işlem yapıldıktan hemen sonra, kullanıcıya işlemin sonucunu göstermek isteriz.
(İşleminiz başarılı şekilde kayıt edildi, Form’da hatalar bulundu vs. gibi)

Tüm CRUD işlemlerinde bu şablonu tekrarlıyorsak ve hemen hemen aynı şeyleri yapıyorsak neden onu bir Component haline getirmeyelim. İşte component’lerin asıl amacı da bu.
Component’ler Klasik PHP‘deki include komutuna benzer şekilde ancak işler, ancak daha yeteneklidirler ve parametre alabilirler.

Şimdi bu söylediklerimizi örnekler ile açıklayalım ama önce bir component oluşturalım.

 php artisan make:component Alert

Bu komut sayesinde Laravel bizim için 2 tane dosya oluşturulacak.
Birincisi app/View/Components klasöründe altında Alert.php isimli Class dosyasıdır. İçeriği de tam olarak şöyle :

<?php
namespace App\View\Components;
use Illuminate\View\Component;
class Alert extends Component
{
/**
* Create a new component instance.
*
* @return void
*/
public function __construct()
{
//
}

/**
* Get the view / contents that represent the component.
*
* @return \Illuminate\Contracts\View\View|\Closure|string
*/
public function render()
{
return view('components.alert');
}
}

İkinci dosya ise resources/views/component klasörü altında alert.blade.php ismindeki Blade dosyası.

İşte bu blade dosyası içerisine sık kullandığınız HTML/Blade kodlarını yazabilir ve istediğiniz Blade dosyası içerisinde kullanabilirsiniz.

Bunu kullanmak içinse tem yapmamız gereken ilgili yere <x-alert />şeklinde komut yazmak.
Dikkat ettiğiniz gibi, <x- yazdıktan hemen sonra component’in ismini (component’in class ismini) yazıyoruz.

alert.blade.php dosyasına istediğiniz kodu yazabilirsiniz. Bu kod <x-alert /> komutu görülen yerlere otomatik olarak enjekte edilecektir.

Ayrıca alert component’ine göndermek istediğiniz bir parametre olursa bunu da HTML attribute ile gönderebilirsiniz.

<x-alert type="error" :message="$message"/>

Bu örnekte type isminde bir parametreyi ve aynı zamanda  message isminde bir parametreyi component’e göndermiş olduk. type ismindeki parametreye “error” şeklinde bir string atadık.
message isimli parametreye ise $message ismindeki bir değişkeni atadık. Dikkat ederseniz değişken ataması yaparsan ilgili parametrenin hemen ömüne iki nokta üstüste işareti (:) koyuyoruz.

Şimdi de gönderdiğimiz bu değişkenleri component’in construct metodunda tanımlamalıyız.
Bu sayede component render edilince otomatik olarak view’a aktarılmış olacaktır.
Yani bu değişkenleri view’a göndermek için sizin ayrıca bir şey yapmanıza gerek yok.

<?php

namespace App\View\Components;

use Illuminate\View\Component;

class Alert extends Component
{

public $type;

public $message;


public function __construct($type, $message)
{
$this->type = $type;
$this->message = $message;
}

public function render()
{
return view('components.alert');
}
}

Gördüğünüz gibi; type ve message isminde 2 adet parametreyi component’e gönderdik.
Component‘in construct metodunda da bu 2 adet parametreyi tanımladık.

Şimdi component’inizin Blade’inin içinde şu şekilde bir kullanım ile bu parametrelere erişebilirsiniz..

<div class="alert alert-{{ $type }}">
{{$message}}
</div>

İşte bu kadar kolay 🙂

Bilindiği üzere Laravel’de modeller arasında kurulabilen 4 çeşit ilişki vardır.

1. One To One (Birden Bire)
2. One To Many (Birden çoğa)
3. Many To One (Çoktan Bire)
4. Many To Many (Çoktan Çoğa)

Diğer ilişki türlerini tahmin az çok edebiliyorsunuzdur, bizim burada duracağımız konu Many to Many özelinde attach, detach ve sync konusu olacak.

Öncelikle şunu açıklayalım : Many to Many ilişki nedir ?
Bir modeldeki bir çok kayıtın, diğer modeldeki bir çok kayıta ilişkisel anlamda bağlı olmasına Many To Many ilişki denir.

Evet, bunu anlamak için en iyisi bir örnekle açıklamak.
authors tablonuz olduğunu düşünün. Bu tabloda yazarlar bulunuyor.
books diye bir tablonuz daha olduğunu düşünün. Bu tabloda da kitaplar bulunuyor.
Bir yazar birden çok kitap yazmış olabilir.
Bir kitabın da birden çok yazarı olabilir.
İşte bu tür ilişkiler Many to Many ilişki olarak tanımlanır.

Many to Many ilişkiyi tanımlamak için ana tablolar olan authors ve books tablolarından ayrı olarak bir tane daha tabloya ihtiyacımız olur : author_book
Bu tablonun author_id ve book_id isimli 2 tane alana sahip olması yeterli.

İşte Book modelimiz.
Gördüğünüz gibi içerisinde authors isminde bir metod var ve ilişki belongsToMany olarak kurulmuş.

namespace App;
use Illuminate\Database\Eloquent\Model;
class Book extends Model
{

public function authors()
{
return $this->belongsToMany('App\Author');
}
}

İşte bu da Author modelimiz.
Gördüğünüz gibi içerisinde books isminde bir metod var ve ilişki belongsToMany olarak kurulmuş.

namespace App;
use Illuminate\Database\Eloquent\Model;

class Author extends Model

public function books()
{
return $this->belongsToMany('App\Book');
}
}

2 tablo arasında ilişkiyi kurduğumuza göre bir kitabın yazarlarını şu şekilde kolayca çekebiliriz.

$book = App\Book::find(1);
foreach ($book->authors as $author) {
dd($author->name);
}

Gelelim esas konumuza 🙂
Laravel bu ilişkileri birbirine bağlamak, koparmak ya da senkronize etmek için 3 yardımcı sunuyor:
attach, detach ve sync

Önce attach’a bakalım

$authorId=2;
$book = App\Book::find(1);
$book->authors()->attach($authorId);

Gördüğünüz gibi 1 nolu kitaba, 2 nolu yazarı atamış (attach etmiş) olduk.

Şimdi de detach

Bir kitaba atanmış bir yazarın ilişkini koparabilir yani o yazarı ilgili kitabın yazarlığından çıkartabiliriz.

$authorId=5;
$book->authors()->detach($authorId);

Yukarıdaki kod sayesinde 5 nolu yazarı, ilgili kitaptan çıkartmış (detach etmiş), ilişkisini koparmış olduk.

Eğer bir kitaptan bir kaç yazarın ilişkisini koparmak isterseniz detach metoduna parametre olarak bir kaç id verebilirsiniz.

$book->authors()->detach(1,5,7,11) gibi.

Ayrıca bir kitaptaki tüm yazarların ilişkisini koparmak istiyorsanız bu defa $book->authors()->detach(); şeklinde detach’a parametre vermeden bunu gerçekleştirebilirsiniz.

Ve son olarak sync

sync metodu ise verilen ilişkiler dışındaki ilişkileri koparır ve verilen ilişkilerin kalmasını sağlar.

Örneğin $book->authors()->sync([5, 10, 15]); şeklinde bir kod ile 5, 10, 15 nolu id’ler dışındakiler silinir ve sadece 5, 10, 15 nolu id’lerin ilişkisi kalır.

Dikkat ettiğiniz üzere; bir çok web uygulaması genelde aynı düzeni kullanır.
Çoğu web uygulamasının genellikle bir menüsü, üst bölümü, alt bölümü, içerik bölümü vs. gibi benzer bölümleri bulunur.

Bir web uygulaması geliştirdiğinizi düşünün.
Bu uygulamanın her sayfasında aynı HTML kodlarını, aynı Javascript kodlarını tekrarladığınızı düşünün. Bu durum hiç iyi olmazdı ve muhtemelen sizi kod yazdığınıza pişman ederdi.

İşte tam da bu noktada Laravel bey, size bir imkan sunuyor : Layout Sistemi.

Web uygulamanızın düzenini bir Blade bileşeni olarak tanımlayabilir ve onu kolayca her sayfanızda kullanabilirsiniz.

Şimdi Şablon Devralma yöntemi ile Layout oluşturmaya bir göz atalım.

<!-- resources/views/app.blade.php -->

<html>
<head>
<title>Uygulamamızın Adı - @yield('baslik')</title>
</head>
<body>

<div class="container">
@yield('icerik')
</div>
</body>
</html>

Yukarıdaki bulunan koda dikkat edin.
@yield(‘baslik’) ile bu komutun tam olarak bulunduğu yere başlığın geleceğini anlatmış oluyoruz.
Aynı şekilde @yield(‘icerik’) komutu ile de buraya içeriğin geleceğini anlatıyoruz.

Şimdi bir alt görünüm tanımlayalım ve yukarıdaki şablonu devralarak kullanalım.

@extends('app')
@section('baslik', 'Bu bir sayfa başlığıdır')
@section('content')
<p>İşte burası da içerik bölümü</p>
@endsection

@extends(‘app’) komutuyla app isimli layout‘u kullanacağımızı belirtiyoruz.
@section(‘baslik’, ‘Bu bir sayfa başlığıdır’) komutu ile layout’ta bulunan ilgili yere bu bilginin yazılmasını sağlıyoruz.

@section(‘icerik’),
<p>İşte burası da içerik bölümü</p>
@endsection

komutlarıyla da icerik bölümüne bu bilginin yazılmasını sağladık.

Böylece oluşturacağımız herhangi bir sayfada, artık app isimli layout‘u kullanabilir ve tekrarlardan kurtulabiliriz.

Laravel‘de isterseniz tüm komutlarınızı web.php yani Route dosyanıza da yazabilirsiniz ancak bu efektif bir yöntem olmayacaktır. Aynı zamanda bu şekilde yapılması MVC yapısına da aykırıdır.
Laravel‘de işlemlerinizi Controller ismi verilen yapılarda gerçekleştirmelisiniz.
Controller dosyaları gerçekte birer text dosyalarıdır ve bir Controller dosyasının yapısı yaklaşık olarak şu şekildedir.

<?php
namespace App\Http\Controllers;
use App\Models\User;
class UserController extends Controller
{

public function show()
{
   return view('profil',['isim='YAZILIMCI.ORG']);
}

}

Gördüğünüz gibi bu Controller‘ın içerisinde show isminde bir fonksiyon bulunuyor. Bu fonksiyon profil isimli View‘i çağırıyor ve ona isim şeklinde bir parametre aktarıyor.

Controller dosyaları Laravel’de app/Http/Controllers klasöründe bulunur. İsterseniz bu dosyayı kendiniz de oluşturabilirsiniz ancak Laravel bunun için bir Artisan komutuna sahip. Dolayısı ile bu komutu kullanarak Controller’ınızı oluşturabilirsiniz. Haydi UserController isminde bir Controller oluşturalım.

php artisan make:controller UserController

Bildiğiniz üzere Laravel’de Controller yapısı “genellikle” şunlar için kullanılıyor.

Veritabanındaki kayıtları listelemek (index)
Veritabanındaki bir kayıtı göstermek (show)
Yeni kayıt oluşturma formunu göstermek (create)
Doldurulan yeni kayıt formunu veritabanına saklamak (store)
Kayıt düzenleme formunu göstermek (edit)
Doldurulan kayıt düzenleme formunu veritabanına saklamak (update)
Bir kayıtı silmek (destroy)

İşte bu gereksinimlerden dolayı Laravel bizlere Controller oluştururken bu metodları otomatik oluşturma seçeneği de sunuyor. Bu sayede index, show, create, store, edit, update, destroy metodları oluşturulan Controller’ın içinde otomatik olarak eklenmiş halde geliyor. Bunu yapmak için Controller oluşturma kodunun yanına –resource kelimesini eklemek yeterli.

php artisan make:controller UserController --resource

Bu komut çalıştırıldıktan sonra oluşan UserController dosyamızın içeriği tam da şu şekilde olacaktır.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

Bu dosyanın içerisinde index, create, show, edit, update, store, destroy gibi metodların otomatik olarak oluşturulduğuna dikkat ettiniz değil mi?

Artık kodlarınızı bu metodlar (fonksiyonlar) içerisine yazabilirsiniz.

index metodunda tüm kayıtları listeleyeceğiniz view’i gösterebilirsiniz.
create metodunda yeni kayıt oluşturma formunun bulunduğu view’i gösterebilirsiniz.
store metodunda yeni kayıt formundan $request ile gelen bilgileri veritabanına kayıt edebilirsiniz.
show metodunda gelen id değerini kullanarak ilgili kayıtı çekebilir ve kayıt gösteren view’inizi gösterebilirsiniz.
edit metodunda kayıt düzenleme formunun bulunduğu view’i gösterebilirsiniz.
update metodunda kayıt düzenleme formundan $request ile gelen bilgileri veritabanına update yapabilirsiniz.
destroy metodu ile de id’si $request ile gelen kayıtı silebilirsiniz.

Peki bu şekilde resource olarak oluşturduğunuz Controller için Route tanımını nasıl yapmalısınız?
O daha da basit. web.php dosyanızda şu şekilde bir tanım yapabilirsiniz.

Route::resource('users', UserController::class);

Bu şekildeki tanımınız sonucunda artık şöyle URL’lere yanıt verilecektir.

/users adresine GET yapılırsa index metodu çalışır.
/users/create adresine GET yapılırsa create metodu çalışır.
/users/ adresine POST yapılırsa store metodu çalışır.
/users/{id} adresine GET yapılırsa show metodu çalışır.
/users/{id}/edit adresine GET yapılırsa edit metodu çalışır.
/users adresine PUT/PATCH yapılırsa update metodu çalışır.
/users{id} adresine DELETE yapılırsa destroy metodu çalışır.

Ayrıca bu Route’lar otomatik olarak isimlendirilmiş olacaktır.
Bu sayede örneğin create URL’sini örneğin View’ınızda elde etmek için

{{route('users.store')}}

komutunu kullanabilirsiniz.

Aynı şekilde Resource ile otomatik oluşturulan Users Route’unun diğer fonksiyonlar için isimleri şöyledir.

users.index
users.create
users.store
user.store
users.show
users.edit
users.update
users.destroy

 

Kısaca; Laravel’de hangi URL’ye girilince ne yapılacağını belirten yapıya Route denir.
Temel Route işlemleri routes klasöründeki web.php dosyasında belirtilir.

Şimdi detaylara takılmadan bunlara bir göz atalım 🙂

localhost:8000/merhaba adresine girilince geriye direkt olarak bir yazı döndürmek isteyelim. İşte bu kadar basit.

Route::get('/merhaba', function () {
return 'Merhaba Dünya';
});

Peki bu defa localhost:8000/user adresine girilince, UserController isimli Controller‘ımızdaki index fonksiyonunu çalıştıralım.

use App\Http\Controllers\UserController;
Route::get('/user', [UserController::class, 'index']);

Şimdi de localhost:8000/iletisim adresine girilince localhost:8000/bize-ulasin adresine otomatik yönlendirme sağlayalım.

Route::redirect('/iletisim', '/bize-ulasin');

Ayrıca localhost:8000/anasayfa adresine girilince index isimli View şablonumuzu da çağırabiliriz. O da şöyle :

Çağırdığımız View‘e bir değişkeni parametre olarak da geçebiliriz. Böylece View‘ın içinde o değişkeni kullanabilirsiniz. Örneğin localhost:8000/hakkimizda adresine girilince aboutUs isimli View‘i gösterelim ve ona isim değişkenini gönderelim.

Route::view('/hakkimizda', 'aboutUs', ['isim' => 'yazilimci.org']);

Peki ya parametre içeren bir URL’miz varsa? İşte onu da şöyle tanımlarız.

localhost:8000/kullanici/117 şeklindeki URL’yi tanımlayıp ve id değişkenini parametre olarak alalım.

Route::get('/kullanici/{id}', function ($id) {
return 'Kullanıcı ID : '.$id;
});

URL’deki parametre sayısı birden fazla da olabilir. Örneğin 2 parametreli bir URL’yi de şu şekilde tanımlarız.

Route::get('/haberler/{haber}/yorumlar/{yorum}', function ($haberId, $yorumId) {
//Burada $haberId ve $yorumId değişkenlerini kullanabiliriz.
});

Yanına ? işareti konulan parametre opsiyonel olur. isim parametresi girilmezse bu örnekte değeri null olur.

Route::get('/kullanici/{isim?}', function ($isim = null) {
return $isim;
});

Eğer istersek tanımladığımız Route’a bir isim de verebiliriz. Bu sayede bu route’un yolunu View’lerde kullanabiliriz.

Route::get(
'/kullanici/profil',
[UserProfileController::class, 'show']
)->name('profil');

İsimlendirmiş olduğumuz Route tanımını kullanarak URL oluşturabiliriz. İşte böyle 🙂

$url = route('profil');

Şimdi bir de Controller’da bu isimlendirilmiş Route’a yönlendirme yapalım.

return redirect()->route('profil');

Laravel’de Route işlemleri gözümüzde büyütülmeyecek kadar basit sayılabilir bir konudur.
Yeterli sayıda uygulama ile siz de Route işlemlerinizi kolayca yapabilir hale gelirsiniz.

 

 

Laravel nasıl kurulur diye düşününce aklımıza uzun kurulum videoları geliyordur.
Ancak Laravel‘in kurulumu ve ilk projenin oluşturulması oldukça basittir.
Detay anlatımları girmeden, kısaca özetlemek gerekirse Laravel’i şu bir kaç adımla kolayca kurabilirsiniz.
Hadi başlayalım.

1. Önce Composer’ı kurun.

Composer, bir paket yönetim sistemi programıdır.
Yani anlaşılır olarak söylemek gerekirse bir uygulama kurulurken, ona bağlı yan uygulamaların da kurulabilmesini sağlar.
Şimdi https://getcomposer.org adresine tıklayın ve Composer‘ı Windows bilgisayarınıza kurun. Bir kaç Next ile bu iş kolayca yapılabilir.
Böylece Laravel nasıl kurulur diye düşünürken, ilk adımı tamamlamış oldunuz bile 🙂

2. Eğer bilgisayarınızda PHP yoksa WAMP kurun.

Laravel ile çalışmak için bilgisayarınızda PHP olmalıdır. Kolay olması amacıyla WAMP programını https://www.wampserver.com/en/ adresinden bilgisayara kurabilirsiniz.
Bu sayede bilgisayarınızda Apache isminde bir web sunucu programı, MYSQL isminde bir veritabanı yönetim sistemi ve PHP kurulmuş olacaktır.

3. Composer ile ilk projenizi oluşturun.

Composer bir komut satırı programıdır. O nedenle Başlat’a tıklayıp, CMD yazıp, Enter’a basın ve aşağıdaki komutu çalıştırın.

composer create-project laravel/laravel benimProjem

Bu komut, bulunduğunuz klasörde benimProjem isminde bir klasör oluşturacak, Laravel‘i kuracak ve benimProjem ismindeki projeyi de oluşturmuş olacaktır.
Gördüğünüz gibi sadece bir komut ile hem Laravel’i bilgisayarınızdaki benimProjem klasörüne kurmuş oldunuz, hem de projeyi oluşturmuş oldunuz.

4. Projenizi çalıştırın

Oluşturulan projenizi çalıştırmak için, benimProjem klasörüne cd benimProjem komutu ile geçin ve aşağıdaki komutu çalıştırarak web sunucusunu başlatın.
Bu web sunucusu Laravel tarafından sağlanan bir web sunucusudur. Bunu başlatmak için Artisan Komutları denilen komutlar kullanılır.
Zannediyoruz Laravel çalışmalarınız boyunca sık sık kullacağınız komutlardan birisi de aşağıdaki komut olacaktır.

php artisan serve

Uygulama Server’ınız artık çalıştığını göre, projenize şu adresten ulaşabilirsiniz.
Elbette, bu projeniz şu an için bir iş yapmıyor.
Bu projede Laravel’in size örnek olması amacıyla oluşturmuş olduğu bir Welcome sayfası bulunuyor.
Ama yine de ilk Laravel deneyiminiz olduğundan dolayı sizin için büyük bir adım.
Tebrikler 🙂

http://localhost:8000/

 

Laravel’de de, diğer dillerde olduğu gibi istediğiniz şeye istediğiniz ismi verebilirsiniz.
Ancak sizden sonra gelecek programcıların kodunuzu anlayabilmeleri gerekir. Ayrıca siz de kodunuzu yazdıktan bir zaman sonra kodunuzu kolayca okuyabilmesi gerekir.
Bu nedenle Laravel’deki isimlendirme kurallarına uymak gerekir. Gelin bu kurallara hızlıca göz atalım.

LARAVEL’DE CONTROLLER İSİMLERİ NASIL OLMALI ?
Controller isimleri TEKİL olmalı, sonunda Controller kelimesi olmalı, kelimeler arasında boşluk olmamalı ve tüm kelimeler büyük harfle başlamalı.

Örneklerle daha kolay anlayacağız 🙂

Doğru kullanım : CustomerController
Doğru kullanım : InvoiceController
Doğru kullanım : CityController
Doğru kullanım : UserController

Yanlış kullanım : CustomersController (çoğul kullanılmamalıydı)
Yanlış kullanım : Invoice (Controller kelimesi ile bitmeliydi)

LARAVEL’DE VERİTABANI TABLO İSİMLERİ NASIL OLMALI ?
Tamamı küçük harflerle yazılmalı, her bir kelimenin arasına alt çizgi ( _ ) konulmalı ve çoğul olmalı.
Doğru kullanım : invoices
Doğru kullanım : invoice_lines
Doğru kullanım : post_comments

Yanlış kullanım : all_invoice (all kelimesine gerek yoktu)
Yanlış kullanım : Customers (tüm harfler küçük harf olmalı)
Yanlış kullanım : postComments (her bir kelime arada alt çizgi ile bölünmeliydi ve tüm harfler küçük harf olmalıydı)

LARAVEL’DE VERİTABANI TABLOLARINDAKİ ALAN  İSİMLERİ  NASIL OLMALI ?

Alan isimlerinin tamamı küçük harflerle yazılmalı, kelime aralarında alt çizgi ( _ ) olmalı. Ayrıca alan isimlerinde tablo ismi kullanılmamalı.

Doğru kullanım : id, content
Doğru kullanım : created_at
Doğru kullanım : image_name

Yanlış kullanım : posts_id (alan isminin başında posts tablosuna referans verilmiş)
Yanlış kullanım : postId (Camel Case kullanılmış, oysa Snake Case kullanılmalıydı)
Yanlış kullanım : forum_title (alan isminin başında forum tablosuna referans verilmiş)

Uzunca bir formu doldurup Gönder tuşuna bastığınız ve form alanlarından birini doldurmayı unuttuğunuz için formu sil baştan yeniden doldurduğunuz oldu mu hiç ?
Normal koşullarda bir Form gönderildikten sonra, eğer formda bir eksiklik veya hata varsa formun kullanıcının önüne dolu haliyle gelmesi gerekir ki kullanıcı o bilgileri yeniden doldurmak zorunda kalmasın.

Laravel’de Form’a “bir önceki post işleminde” girilen bilgileri almak için “old” yardımcısını kullanın.
Aşağıdaki kodda görüldüğü üzere, input elementinin value özelliğinde şöyle bir kod var :

{{old('mobile_phone',$data->mobile_phone)}}

Yukarıdaki kod ile bir önceki post edilen form’daki eski mobile_phone değişkenini yazar.
İkinci parametre ile eğer form daha önceden post edilmemişse, yani mobile_phone değeri boş ise data->mobile_phone ile veritabanında bulunan değer yazdırılır.

Bir daha açıklamak gerekirse; aşağıdaki kodda şunu söylemiş oluyoruz :
Input elementinin value özelliğine; post edilen mobile_phone değerini yaz, eğer post edilen bilgi yok ise, veritabanından gelen mobile_phone değerini yaz.

<p><input maxlength="10" name="mobile_phone" type="tel" value="{{old('mobile_phone',$data->;mobile_phone)}}" /></p>