2. Adım: görünümler ve sayfa şablonlarıyla bir Docgo uygulaması oluşturmaStep 2: Create a Django app with views and page templates

Önceki adım: Visual Studio projesi ve çözümü oluşturmaPrevious step: Create a Visual Studio project and solution

Visual Studio projesinde şimdiye kadar olan özellikler, bir veya daha fazla Docgo uygulamasıçalışabilen bir docgo projesininyalnızca site düzeyi bileşenleridir.What you have so far in the Visual Studio project are only the site-level components of a Django project, which can run one or more Django apps. Sonraki adım, ilk uygulamanızı tek bir sayfa ile oluşturmaktır.The next step is to create your first app with a single page.

Bu adımda şu adımları öğrenebilirsiniz:In this step you now learn how to:

  • Tek sayfalı bir Docgo uygulaması oluşturma (adım 2-1)Create a Django app with a single page (step 2-1)
  • Uygulamayı Docgo projesinden çalıştırın (adım 2-2)Run the app from the Django project (step 2-2)
  • HTML kullanarak bir görünüm işleme (adım 2-3)Render a view using HTML (step 2-3)
  • Docgo sayfa şablonu kullanarak bir görünüm işleme (adım 2-4)Render a view using a Django page template (step 2-4)

Adım 2-1: varsayılan yapıyla uygulama oluşturmaStep 2-1: Create an app with a default structure

Docgo uygulaması, belirli bir amaç için ilgili dosyalar kümesi içeren ayrı bir Python paketidir.A Django app is a separate Python package that contains a set of related files for a specific purpose. Bir Docgo projesi herhangi bir sayıda uygulama içerebilir ve bu da bir Web konağının tek bir etki alanı adından herhangi bir sayıda ayrı giriş noktasına hizmeti verebildiği olguyu yansıtır.A Django project can contain any number of apps, which reflects the fact that a web host can serve any number of separate entry points from a single domain name. Örneğin, contoso.com gibi bir etki alanı için bir Docgo projesi, için bir uygulama www.contoso.com , support.contoso.com için ikinci bir uygulama ve docs.contoso.com için bir üçüncü uygulama içerebilir.For example, a Django project for a domain like contoso.com might contain one app for www.contoso.com, a second app for support.contoso.com, and a third app for docs.contoso.com. Bu durumda, Docgo projesi site düzeyinde URL yönlendirme ve ayarlarını işler ( URLs.py ve Settings.py dosyalarında), her uygulamanın kendi ayrı stil ve kendi iç yönlendirme, görünümler, modeller, statik dosyalar ve yönetim arabirimi aracılığıyla davranışı vardır.In this case, the Django project handles site-level URL routing and settings (in its urls.py and settings.py files), while each app has its own distinct styling and behavior through its internal routing, views, models, static files, and administrative interface.

Bir Docgo uygulaması genellikle standart bir dosya kümesiyle başlar.A Django app typically begins with a standard set of files. Visual Studio, aynı amaca hizmet eden tümleşik bir menü komutuyla birlikte bir Docgo projesi içinde Docgo uygulamasını başlatmak için öğe şablonları sağlar:Visual Studio provides item templates to initialize a Django app within a Django project, along with an integrated menu command that serves the same purpose:

  • Şablonlar: Çözüm Gezgini, projeye sağ tıklayın ve Add > Yeni öğeEkle ' yi seçin.Templates: In Solution Explorer, right-click the project and select Add > New item. Yeni öğe Ekle Iletişim kutusunda docgo 1,9 uygulama şablonunu seçin, ad alanında uygulama adını belirtin ve Tamam' ı seçin.In the Add New Item dialog, select the Django 1.9 App template, specify the app name in the Name field, and select OK.

  • Tümleşik komut: Çözüm Gezgini' de projeye sağ tıklayın ve Add > docgo uygulamasıEkle ' yi seçin.Integrated command: In Solution Explorer, right-click the project and select Add > Django app. Bu komut sizden bir ad ister ve bir Docgo 1,9 uygulaması oluşturur.This command prompts you for a name and creates a Django 1.9 app.

    Docgo uygulaması ekleme menü komutu

Her iki yöntemi kullanarak, "Hellodocgoapp" adlı bir uygulama oluşturun.Using either method, create an app with the name "HelloDjangoApp". Sonuç, aşağıdaki tabloda açıklandığı gibi öğeleri içeren bu ada sahip projenizdeki bir klasördür.The result is a folder in your project with that name that contains items as described in the table that follows.

Çözüm Gezgini 'de docgo uygulama dosyaları

ÖğeItem AçıklamaDescription
__init _ _ . Kopyala__init__.py Uygulamayı paket olarak tanımlayan dosya.The file that identifies the app as a package.
geçişlermigrations Docgo 'nun, modellerdeki değişikliklerle uyum sağlamak üzere veritabanını güncelleştiren betikleri sakladığı bir klasör.A folder in which Django stores scripts that update the database to align with changes to the models. Docgo 'nun geçiş araçları, geçerli modellerle eşleşecek şekilde veritabanının önceki bir sürümüne gerekli değişiklikleri uygular.Django's migration tools then apply the necessary changes to any previous version of the database so that it matches the current models. Geçişleri kullanarak, yaptığınız geçişlerinizi modellerinize koruyun ve temel veritabanı şemasını Docgo 'ya izin verin.Using migrations, you keep your focus on your models and let Django handle the underlying database schema. Geçişler adım 6 ' da ele alınmıştır. Şimdilik, klasör yalnızca bir * _ _ init _ _ . Kopyala* dosyası içerir (klasörün kendi Python paketini tanımladığını gösterir).Migrations are discussed in step 6; for now, the folder simply contains an __init__.py file (indicating that the folder defines its own Python package).
templatestemplates Uygulama adıyla eşleşen bir klasör içinde tek bir dosya index.html Içeren Docgo sayfa şablonları için bir klasör.A folder for Django page templates containing a single file index.html within a folder matching the app name. (Visual Studio 2017 15,7 ve önceki sürümlerde dosya doğrudan Şablonlar altında bulunur ve adım 2-4 alt klasörü oluşturmanızı söyler.) Şablonlar, görünümün dinamik olarak bir sayfayı işlemek için bilgi ekleyebileceği HTML bloklarıdır.(In Visual Studio 2017 15.7 and earlier, the file is contained directly under templates and step 2-4 instructs you to create the subfolder.) Templates are blocks of HTML into which views can add information to dynamically render a page. index.html içindeki gibi sayfa şablonu "değişkenleri", {{ content }} Bu makalenin ilerleyen kısımlarında açıklandığı gibi dinamik değerler için yer tutuculardır (2. adım). index.htmlPage template "variables," such as {{ content }} in index.html, are placeholders for dynamic values as explained later in this article (step 2). Genellikle Docgo uygulamaları, uygulama adıyla eşleşen bir alt klasöre yerleştirerek şablonları için bir ad alanı oluşturur.Typically Django apps create a namespace for their templates by placing them in a subfolder that matches the app name.
admin.pyadmin.py Uygulamanın yönetim arabirimini genişletmenizi sağlayan Python dosyası (bkz. 6. adım), bir veritabanındaki verileri tohum ve düzenlemek için kullanılır.The Python file in which you extend the app's administrative interface (see step 6), which is used to seed and edit data in a database. Başlangıçta, bu dosya yalnızca ifadesini içerir, from django.contrib import admin .Initially, this file contains only the statement, from django.contrib import admin. Varsayılan olarak, Docgo, URLs.pyiçindeki mevcut girişlerin açıklamasını kaldırarak, docgo projesinin Settings.py dosyasındaki girişler aracılığıyla standart bir yönetim arabirimi içerir.By default, Django includes a standard administrative interface through entries in the Django project's settings.py file, which you can turn on by uncommenting existing entries in urls.py.
apps.pyapps.py Uygulama için bir yapılandırma sınıfı tanımlayan Python dosyası (bu tablodan sonra aşağıya bakın).A Python file that defines a configuration class for the app (see below, after this table).
models.pymodels.py Modeller, uygulamanın temel alınan veritabanıyla etkileşime geçen görünümler tarafından tanımlanan veri nesneleridir (bkz. 6. adım).Models are data objects, identified by functions, through which views interact with the app's underlying database (see step 6). Docgo, uygulamaların bu ayrıntılarla ilgilenmesini gerektirmeyen veritabanı bağlantısı katmanını sağlar.Django provides the database connection layer so that apps don't need to concern themselves with those details. Models.py dosyası, modellerinizin oluşturulacağı varsayılan bir yerdir ve başlangıçta yalnızca ifadesini içerir from django.db import models .The models.py file is a default place in which to create your models, and initially contains only the statement, from django.db import models.
tests.pytests.py Birim testlerinin temel yapısını içeren bir Python dosyası.A Python file that contains the basic structure of unit tests.
views.pyviews.py Görünümler, genellikle bir HTTP isteği alıp HTTP yanıtı döndüren Web sayfaları olarak düşündüğünüzden oluşur.Views are what you typically think of as web pages, which take an HTTP request and return an HTTP response. Görünümler genellikle Web tarayıcılarının nasıl görüntüleneceğini bildiğiniz HTML olarak işlenir, ancak bir görünümün görünür olması gerekmez (bir ara form gibi).Views typically render as HTML that web browsers know how to display, but a view doesn't necessarily have to be visible (like an intermediate form). Bir görünüm bir Python işlevi tarafından tanımlanır ve bu da sorumluluğu tarayıcıya gönderilmek üzere HTML 'yi işlemek için kullanılır.A view is defined by a Python function whose responsibility is to render the HTML to send to the browser. Views.py dosyası, görünümlerin oluşturulacağı ve başlangıçta yalnızca deyimin bulunduğu varsayılan bir yerdir from django.shortcuts import render .The views.py file is a default place in which to create views, and initially contains only the statement, from django.shortcuts import render.

Apps.py Içeriği "Hellodocgoapp" adı kullanılırken şöyle görünür:The contents of apps.py appears as follows when using the name "HelloDjangoApp":

from django.apps import AppConfig

class HelloDjangoAppConfig(AppConfig):
    name = 'HelloDjango'

Soru: Visual Studio 'da komut satırında uygulama oluşturmaktan farklı bir Docgo uygulaması oluşturuluyor mu?Question: Is creating a Django app in Visual Studio any different from creating an app on the command line?

Cevap: Add > docgo uygulaması Ekle komutunu çalıştırma veya Add > docgo uygulama şablonuylaYeni öğe Ekle ' nin kullanılması docgo komutuyla aynı dosyaları oluşturur manage.py startapp <app_name> .Answer: Running the Add > Django app command or using Add > New Item with a Django app template produces the same files as the Django command manage.py startapp <app_name>. Visual Studio 'da uygulama oluşturmanın avantajı, uygulama klasörünün ve tüm dosyalarının proje ile otomatik olarak tümleştirildiği bir avantajdır.The benefit to creating the app in Visual Studio is that the app folder and all its files are automatically integrated into the project. Projenizde herhangi bir sayıda uygulama oluşturmak için aynı Visual Studio komutunu kullanabilirsiniz.You can use the same Visual Studio command to create any number of apps in your project.

Adım 2-2: uygulamayı Docgo projesinden çalıştırmaStep 2-2: Run the app from the Django project

Bu noktada, projeyi Visual Studio 'da yeniden çalıştırırsanız (araç çubuğu düğmesini veya hata ayıklama > başlatma hata ayıklamayıkullanarak), yine de varsayılan sayfayı görürsünüz.At this point, if you run the project again in Visual Studio (using the toolbar button or Debug > Start Debugging), you still see the default page. Uygulamaya özgü bir sayfa tanımlamanız ve uygulamayı Docgo projesine eklemeniz gerektiğinden hiçbir uygulama içeriği görünmez:No app content appears because you need to define an app-specific page and add the app to the Django project:

  1. Merhaba Docgoapp klasöründe, "index" adlı bir görünümü tanımlayan aşağıdaki kodla eşleşecek şekilde views.py değiştirin:In the HelloDjangoApp folder, modify views.py to match the code below, which defines a view named "index":

    from django.shortcuts import render
    from django.http import HttpResponse
    
    def index(request):
        return HttpResponse("Hello, Django!")
    
  2. BasicProject klasöründe (adım 1 ' de oluşturulur), URLs.py öğesini en azından aşağıdaki kodla eşleşecek şekilde değiştirin (isterseniz, komutlarıaçıklamalarını koruyabilirsiniz):In the BasicProject folder (created in step 1), modify urls.py to at least match the following code (you can retain the instructive comments if you like):

    from django.conf.urls import include, url
    import HelloDjangoApp.views
    
    # Django processes URL patterns in the order they appear in the array
    urlpatterns = [
        url(r'^$', HelloDjangoApp.views.index, name='index'),
        url(r'^home$', HelloDjangoApp.views.index, name='home'),
    ]
    

    Her URL modelinde, Docgo 'nun belirli siteyle ilgili URL 'Leri yönlendirdiğini (diğer bir deyişle, izleyen bölüm) açıklayan görünümler açıklanmaktadır https://www.domain.com/ .Each URL pattern describes the views to which Django routes specific site-relative URLs (that is, the portion that follows https://www.domain.com/). urlPatternsNormal ifadeyle başlayan ilk giriş, ^$ "/" site kökünün yönlendirimiyle.The first entry in urlPatterns that starts with the regular expression ^$ is the routing for the site root, "/". İkinci girdi, ^home$ özellikle "/Home" yollar.The second entry, ^home$ specifically routes "/home". Aynı görünümde herhangi bir sayıda üretim akışı olabilir.You can have any number of routings to the same view.

  3. Hello, Docgo iletisini görmek için projeyi yeniden çalıştırın!Run the project again to see the message Hello, Django! görünümü tarafından tanımlandığı gibi.as defined by the view. İşiniz bittiğinde sunucuyu durdurun.Stop the server when you're done.

Kaynak denetimine KaydetCommit to source control

Kodunuzda değişiklik yaptığınız ve bunları başarıyla test ettiğiniz için, değişiklikleri gözden geçirmek ve kaynak denetimine uygulamak harika bir süredir.Because you've made changes to your code and have tested them successfully, now is a great time to review and commit your changes to source control. Bu öğreticideki sonraki adımlar, kaynak denetimine yeniden kaydolmasını ve bu bölüme geri dönebilmeniz için uygun zamanları hatırlatır.Later steps in this tutorial remind you of appropriate times to commit to source control again, and refer you back to this section.

  1. Takım Gezginigittiği, Visual Studio 'nun alt kısmındaki (aşağıda daire içinde) bulunan değişiklikler düğmesini seçin.Select the changes button along the bottom of Visual Studio (circled below), which navigates to Team Explorer.

    Visual Studio durum çubuğunda kaynak denetimi değişiklikleri düğmesi

  2. Takım Gezgini, "Ilk Docgo uygulaması oluşturma" gibi bir teslim iletisi girin ve Tümünü Yürüt' ü seçin.In Team Explorer, enter a commit message like "Create initial Django app" and select Commit All. Tamamlama tamamlandığında yerel olarak oluşturulan bir Ileti kaydı görürsünüz <hash> . Değişikliklerinizi sunucuyla paylaşmak için eşitleyin.When the commit is complete, you see a message Commit <hash> created locally. Sync to share your changes with the server. Değişiklikleri uzak deponuza göndermek istiyorsanız Eşitle' yi ve ardından giden işlemeleraltında Gönder ' i seçin.If you want to push changes to your remote repository, select Sync, then select Push under Outgoing Commits. Ayrıca, uzaktan göndermeden önce birden çok yerel işleme de birikmeniz gerekir.You can also accumulate multiple local commits before pushing to remote.

    Takım Gezgini 'da yürütmeleri uzak 'a gönderme

Soru: yönlendirme dizelerinden önce ' r ' öneki nedir?Question: What is the 'r' prefix before the routing strings for?

Cevap: Python 'daki bir dizedeki ' r ' öneki "RAW" anlamına gelir, bu da Python 'un dize içindeki herhangi bir karakteri atmamasını sağlar.Answer: The 'r' prefix on a string in Python means "raw," which instructs Python to not escape any characters within the string. Normal ifadeler çok sayıda özel karakter kullandığından, ' r ' önekini kullanmak Bu dizelerin bir dizi ' ' kaçış karakteri içerenden çok daha kolay olmasını sağlar \ .Because regular expressions use many special characters, using the 'r' prefix makes those strings much easier to read than if they contained a number of '\' escape characters.

Soru: URL yönlendirme girişlerinde ^ ve $ karakterlerinin anlamı nedir?Question: What do the ^ and $ characters mean in the URL routing entries?

Cevap: URL düzenlerini tanımlayan normal ifadelerde, ^ "satır başlangıcı" ve $ "satır sonu" anlamına gelir ve burada URL 'Ler site köküne (izleyen bölüm) göre değişir https://www.domain.com/ .Answer: In the regular expressions that define URL patterns, ^ means "start of line" and $ means "end of line," where again the URLs are relative to the site root (the part that follows https://www.domain.com/). Normal ifade ^$ etkin bir şekilde "boş" anlamına gelir ve bu nedenle tam URL ile eşleşir https://www.domain.com/ (site köküne hiçbir şey eklenmez).The regular expression ^$ effectively means "blank" and therefore matches the full URL https://www.domain.com/ (nothing added to the site root). Desenler ^home$ tam olarak eşleşir https://www.domain.com/home/ .The pattern ^home$ matches exactly https://www.domain.com/home/. (Docgo, sondaki/ın örüntüme düzeniyle eşleştirmeyi kullanmaz.)(Django doesn't use the trailing / in pattern matching.)

Normal ifadede ' de olduğu gibi sondaki $ kullanmıyorsanız ^home , URL deseninin "Home", "ödev", "Homestead" ve "home192837" gibi "Home" ile başlayan Tüm URL 'ler eşleşir.If you don't use a trailing $ in a regular expression, as with ^home, then URL pattern matches any URL that begins with "home" such as "home", "homework", "homestead", and "home192837".

Farklı normal ifadelerle denemeler yapmak için pythex.orgadresindeki regex101.com gibi çevrimiçi araçları deneyin.To experiment with different regular expressions, try online tools such as regex101.com at pythex.org.

Adım 2-3: HTML kullanarak bir görünüm IşlemeStep 2-3: Render a view using HTML

Şimdiye index kadar views.py sahip olduğunuz işlev, sayfa için düz metin bir HTTP yanıtından daha fazla şey oluşturuyor.The index function that you have so far in views.py generates nothing more than a plain-text HTTP response for the page. Birçok gerçek dünyada Web sayfası, genellikle canlı verileri birleştiren zengin HTML sayfalarıyla yanıt verir.Most real-world web pages, of course, respond with rich HTML pages that often incorporate live data. Aslında, bir işlevi kullanarak bir görünüm tanımlamanın birincil nedeni, bu içeriği dinamik olarak oluşturabilir.Indeed, the primary reason to define a view using a function is so you can generate that content dynamically.

Bağımsız değişkeni HttpResponse yalnızca bir dize olduğundan, bir dize içinde ISTEDIĞINIZ HTML 'yi oluşturabilirsiniz.Because the argument to HttpResponse is just a string, you can build up any HTML you like within a string. Basit bir örnek olarak, index aşağıdaki kodla (var olan from deyimleri koruyarak), sayfayı her yenilediğiniz zaman güncelleştirilmiş dinamik içeriği kullanarak bir HTML yanıtı oluşturan şu kodla değiştirin:As a simple example, replace the index function with the following code (keeping the existing from statements), which generates an HTML response using dynamic content that's updated every time you refresh the page:

from datetime import datetime

def index(request):
    now = datetime.now()

    html_content = "<html><head><title>Hello, Django</title></head><body>"
    html_content += "<strong>Hello Django!</strong> on " + now.strftime("%A, %d %B, %Y at %X")
    html_content += "</body></html>"

    return HttpResponse(html_content)

"Hello Docgo! " gibi bir iletiyi görmek için projeyi yeniden çalıştırın.Run the project again to see a message like "Hello Django! Pazartesi günü, 16 Nisan 2018, 16:28:10 ".on Monday, 16 April, 2018 at 16:28:10". Zamanı güncelleştirmek ve içeriğin her istekle birlikte oluşturulduğunu onaylamak için sayfayı yenileyin.Refresh the page to update the time and confirm that the content is being generated with each request. İşiniz bittiğinde sunucuyu durdurun.Stop the server when you're done.

İpucu

Projeyi durdurma ve yeniden başlatmanın bir kısayolu, hata ayıklama > yeniden başlatma menü komutunu (CTRL + SHIFT + F5) veya hata ayıklama araç çubuğundaki Yeniden Başlat düğmesini kullanmaktır:A shortcut to stopping and restarting the project is to use the Debug > Restart menu command (Ctrl+Shift+F5) or the Restart button on the debugging toolbar:

Visual Studio 'da hata ayıklama araç çubuğunda yeniden Başlat düğmesi

Adım 2-4: sayfa şablonu kullanarak bir görünüm IşlemeStep 2-4: Render a view using a page template

Kodda HTML oluşturma çok küçük sayfalar için sorunsuz çalışıyor, ancak sayfalar daha karmaşık bir şekilde elde ederken, daha sonra dinamik, kod tarafından oluşturulan içerik eklediğiniz "sayfa şablonları" olarak sayfanızın statik HTML parçalarını (CSS ve JavaScript dosyalarına başvurularıyla birlikte) korumak istersiniz.Generating HTML in code works fine for very small pages, but as pages get more sophisticated you typically want to maintain the static HTML parts of your page (along with references to CSS and JavaScript files) as "page templates" into which you then insert dynamic, code-generated content. Önceki bölümde yalnızca çağrının Tarih ve saati now.strftime dinamiktir. Bu, diğer tüm içeriklerin bir sayfa şablonuna yerleştirilebileceği anlamına gelir.In the previous section, only the date and time from the now.strftime call is dynamic, which means all the other content can be placed in a page template.

Bir Docgo sayfa şablonu, ' {{ de olduğu gibi ve tarafından ayırıcı olan "değişkenler" adlı herhangi bir sayıda değiştirme belirteci içerebilen BIR HTML bloğudur }} {{ content }} .A Django page template is a block of HTML that can contain any number of replacement tokens called "variables" that are delineated by {{ and }}, as in {{ content }}. Docgo 'nın şablon oluşturma modülü daha sonra değişkenleri kodda sağladığınız Dinamik içerikle değiştirir.Django's templating module then replaces variables with dynamic content that you provide in code.

Aşağıdaki adımlarda sayfa şablonlarının kullanımı gösterilmektedir:The following steps demonstrate the use of page templates:

  1. Docgo projesini içeren BasicProject klasörünün altında, Settings.py dosyasını açın ve "Hellodocgoapp" uygulama adını INSTALLED_APPS listeye ekleyin.Under the BasicProject folder, which contains the Django project, open settings.py file and add the app name, "HelloDjangoApp", to the INSTALLED_APPS list. Uygulamanın listeye eklenmesi, Docgo projesine, bir uygulama içeren bu adın bir klasörü olduğunu söyler:Adding the app to the list tells the Django project that there's a folder of that name containing an app:

    INSTALLED_APPS = [
        'HelloDjangoApp',
        # Other entries...
    ]
    
  2. Ayrıca, Settings.py' de, TEMPLATES nesnenin aşağıdaki satırı (varsayılan olarak dahildir) içerdiğinden emin olun. Bu, docgo 'nun yüklü bir uygulamanın Şablonlar klasöründeki şablonları aramasını sağlar:Also in settings.py, make sure the TEMPLATES object contains the following line (included by default), which instructs Django to look for templates in an installed app's templates folder:

    'APP_DIRS': True,
    
  3. Merhaba docgoapp klasöründe, bir değişken içerdiğini gözlemlemek için Templates/hellodocgoapp/index.html sayfa şablonu dosyasını (veya vs 2017 15,7 ve önceki sürümlerde Şablonlar/index.html ) açın {{ content }} :In the HelloDjangoApp folder, open the templates/HelloDjangoApp/index.html page template file (or templates/index.html in VS 2017 15.7 and earlier), to observe that it contains one variable, {{ content }}:

    <html>
    <head><title></title></head>
    
    <body>
    
    {{ content }}
    
    </body>
    </html>
    
  4. Merhaba Docgoapp klasöründe views.py ' ı açın ve index işlevi, yardımcı işlevini kullanan aşağıdaki kodla değiştirin django.shortcuts.render .In the HelloDjangoApp folder, open views.py and replace the index function with the following code that uses the django.shortcuts.render helper function. renderYardımcı, sayfa şablonlarıyla çalışmak için basitleştirilmiş bir arabirim sağlar.The render helper provides a simplified interface for working with page templates. Tüm mevcut deyimleri tutmaya dikkat edin from .Be sure to keep all existing from statements.

    from django.shortcuts import render   # Added for this step
    
    def index(request):
        now = datetime.now()
    
        return render(
            request,
            "HelloDjangoApp/index.html",  # Relative path from the 'templates' folder to the template file
            # "index.html", # Use this code for VS 2017 15.7 and earlier
            {
                'content': "<strong>Hello Django!</strong> on " + now.strftime("%A, %d %B, %Y at %X")
            }
        )
    

    İçin ilk bağımsız değişken, render görebileceğiniz gibi, istek nesnesidir ve sonra uygulamanın Şablonlar klasörü içindeki şablon dosyasının göreli yolu gelir.The first argument to render, as you can see, is the request object, followed by the relative path to the template file within the app's templates folder. Uygunsa, desteklediği görünüm için bir şablon dosyası adlandırılır.A template file is named for the view it supports, if appropriate. Üçüncü bağımsız değişkeni, render daha sonra şablonun başvurduğu değişkenlerin bir sözlüğüdür.The third argument to render is then a dictionary of variables that the template refers to. Sözlüğe nesne ekleyebilirsiniz, bu durumda şablondaki bir değişken başvuru yapabilir {{ object.property }} .You can include objects in the dictionary, in which case a variable in the template can refer to {{ object.property }}.

  5. Projeyi çalıştırın ve çıktıyı gözlemleyin.Run the project and observe the output. Bu şekilde, şablonun çalışıp çalışmadığını belirten, 2-2 adımında görülen benzer bir ileti görmeniz gerekir.You should see a similar message to that seen in step 2-2, indicating that the template works.

    Ancak, özellikte kullandığınız HTML 'nin content yalnızca düz metin olarak işlediğini gözlemleyin, çünkü render işlev OTOMATIK olarak HTML 'den çıkar.Observe, however, that the HTML you used in the content property renders only as plain text because the render function automatically escapes that HTML. Otomatik kaçış, yanlışlıkla güvenlik açıklarına ekleme saldırıları önler: geliştiriciler genellikle bir sayfadan giriş toplar ve bir şablon yer tutucusu aracılığıyla başka bir değer olarak bu değeri kullanır.Automatic escaping prevent accidental vulnerabilities to injection attacks: developers often gather input from one page and use it as a value in another through a template placeholder. Kaçış Ayrıca, HTML 'nin sayfa şablonunda ve kodun dışında tutulması için daha iyi bir anımsatıcı işlevi görür.Escaping also serves as a reminder that it's again best to keep HTML in the page template and out of the code. Neyse ki, gerektiğinde ek değişkenler oluşturmanın basit bir önemi vardır.Fortunately, it's a simple matter to create additional variables where needed. Örneğin, bir sayfa başlığı ekleyen ve sayfa şablonunda tüm biçimlendirmeyi tutan aşağıdaki işaretlerle eşleşecek şekilde index.html 'yi şablonlarla değiştirin:For example, change index.html with templates to match the following markup, which adds a page title and keeps all formatting in the page template:

    <html>
        <head>
            <title>{{ title }}</title>
        </head>
        <body>
            <strong>{{ message }}</strong>{{ content }}
        </body>
    </html>
    

    Ardından index , sayfa şablonundaki tüm değişkenler için değerler sağlamak üzere görünüm işlevini aşağıdaki şekilde yazın:Then write the index view function as follows, to provide values for all the variables in the page template:

    def index(request):
        now = datetime.now()
    
        return render(
            request,
            "HelloDjangoApp/index.html",  # Relative path from the 'templates' folder to the template file
            # "index.html", # Use this code for VS 2017 15.7 and earlier
            {
                'title' : "Hello Django",
                'message' : "Hello Django!",
                'content' : " on " + now.strftime("%A, %d %B, %Y at %X")
            }
        )
    
  6. Sunucuyu durdurup projeyi yeniden başlatın ve sayfanın artık düzgün şekilde işlediğini gözlemleyin:Stop the server and restart the project, and observe that the page now renders properly:

    Şablonu kullanarak uygulamayı çalıştırma

  7. Visual Studio 2017 sürüm 15,7 ve önceki sürümler: son bir adım olarak, şablonlarınızı uygulamanız ile aynı adlı bir alt klasöre taşıyın. Bu, bir ad alanı oluşturur ve projeye ekleyebileceğiniz diğer uygulamalarla olası çakışmaları önler.Visual Studio 2017 version 15.7 and earlier: As a final step, move your templates into a subfolder named the same as your app, which creates a namespace and avoids potential conflicts with other apps you might add to the project. (VS 2017 'deki şablonlar 15.8 + bunu sizin için otomatik olarak yapın.) Diğer bir deyişle, Merhaba docgoappadlı şablonlarda bir alt klasör oluşturun, index.html 'yi bu alt klasöre taşıyın ve index Görünüm Işlevini, şablonun yeni yoluna, Merhaba docgoapp/index.htmlöğesine başvuracak şekilde değiştirin.(The templates in VS 2017 15.8+ do this for you automatically.) That is, create a subfolder in templates named HelloDjangoApp, move index.html into that subfolder, and modify the index view function to refer to the template's new path, HelloDjangoApp/index.html. Ardından projeyi çalıştırın, sayfanın düzgün şekilde işlediğini doğrulayın ve sunucuyu durdurun.Then run the project, verify that the page renders properly, and stop the server.

  8. Değişikliklerinizi kaynak denetimine kaydedin ve isterseniz, uzak deponuzu adım 2-2' de açıklandığı gibi güncelleştirin.Commit your changes to source control and update your remote repository, if desired, as described under step 2-2.

Soru: sayfa şablonlarının ayrı bir dosyada olması gerekir mi?Question: Do page templates have to be in a separate file?

Cevap: Şablonlar genellikle ayrı HTML dosyalarında tutulabilse de, bir satır içi şablonu da kullanabilirsiniz.Answer: Although templates are usually maintained in separate HTML files, you can also use an inline template. Ancak, biçimlendirme ve kod arasında temiz ayrımı sürdürmek için, ayrı bir dosya kullanılması önerilir.Using a separate file is recommended, however, to maintain a clean separation between markup and code.

Soru: şablonlar. html dosya uzantısını kullanmalıdır mi?Question: Must templates use the .html file extension?

Yanıt: sayfa şablonu dosyaları için . html uzantısı tamamen isteğe bağlıdır; çünkü her zaman, işleve ikinci bağımsız değişkende dosyanın tam yolunu her zaman belirlersiniz render .Answer: The .html extension for page template files is entirely optional, because you always identify the exact relative path to the file in the second argument to the render function. Ancak, Visual Studio (ve diğer düzenleyiciler), genellikle, sayfa şablonlarının tamamen HTML olmaması durumunda kod tamamlama ve . html dosyalarıyla söz dizimi renklendirme gibi özellikler sağlar.However, Visual Studio (and other editors) typically give you features like code completion and syntax coloration with .html files, which outweighs the fact that page templates are not strictly HTML.

Aslında, bir Docgo projesiyle çalışırken Visual Studio, düzenlemekte olduğunuz HTML dosyasının gerçekte bir Docgo şablonu olduğu zaman otomatik olarak algılar ve belirli otomatik tamamlanmış özellikleri sağlar.In fact, when you're working with a Django project, Visual Studio automatically detects when the HTML file you're editing is actually a Django template, and provides certain auto-complete features. Örneğin, bir Docgo sayfa şablonu açıklaması yazmaya başladığınızda, {# Visual Studio otomatik olarak kapanış #} karakterleri verir.For example, when you start typing a Django page template comment, {#, Visual Studio automatically gives you the closing #} characters. Açıklama seçimi ve seçim komutlarının açıklamasını kaldırın ( Edit > Gelişmiş düzenleme menüsünde ve araç çubuğunda), HTML açıklamaları yerine şablon açıklamalarını de kullanır.The Comment Selection and Uncomment Selection commands (on the Edit > Advanced menu and on the toolbar) also use template comments instead of HTML comments.

Soru: projeyi çalıştırdığımda, şablonun bulunamadığını belirten bir hata görüyorum.Question: When I run the project, I see an error that the template cannot be found. Ne oldu?What's wrong?

Cevap: şablonun bulunamadığını belirten hatalar görürseniz, uygulamayı listede Docgo projesinin Settings.py eklediğinizden emin olun INSTALLED_APPS .Answer: If you see errors that the template cannot be found, make sure you added the app to the Django project's settings.py in the INSTALLED_APPS list. Bu giriş olmadan Docgo, uygulamanın Şablonlar klasörünü aramak için bilgi vermez.Without that entry, Django won't know to look in the app's templates folder.

Soru: Template namespacing neden önemlidir?Question: Why is template namespacing important?

Cevap: Docgo, işlevde başvurulan bir şablonu ararken render , ilk bulduğu dosyayı göreli yol ile eşleşen bir dosya kullanır.Answer: When Django looks for a template referred to in the render function, it uses whatever file it finds first that matches the relative path. Şablonlar için aynı klasör yapılarını kullanan aynı projede birden çok Docgo uygulamanız varsa, bu, bir uygulamanın başka bir uygulamadaki bir şablonu yanlışlıkla kullanması olasıdır.If you have multiple Django apps in the same project that use the same folder structures for templates, it's likely that one app will unintentionally use a template from another app. Bu tür hatalardan kaçınmak için her zaman bir uygulamanın Şablonlar klasörü altında, herhangi bir yinelemeyi önlemek için uygulamanın adıyla eşleşen bir alt klasör oluşturun.To avoid such errors, always create a subfolder under an app's templates folder that matches the name of the app to avoid any and all duplication.

Sonraki adımlarNext steps

Daha derin gitGo deeper