整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
做后臺項目時候，使用聲明式組件比較多，就是寫一個.vue文件，在里面寫 template、script、style哪里需要，就在哪里導入。
而對于前臺項目而言，我們期望可以直接通過方法的形式調用，利用函數式組件，在封裝時除了要寫.vue，還要多一個手動渲染和卸載的步驟。我們可以通過 h 函數可以生成一個vnode，該vnode利用render函數渲染和卸載。
<template>
<!-- 聲明式組件 -->
<el-row class="mb-4">
<el-button type="primary" @click="open">Primary</el-button>
<el-button type="success">Success</el-button>
</el-row>
</template>
<script lang="ts" setup>
// 函數式組件
import { ElMessage } from 'element-plus'
// 通常是在某個交互完成時觸發
const open=()=> {
ElMessage('this is a message.')
}
</script>
Vue中，提供了一個h()函數用于創建 vnodes。創建虛擬節點時會多種不同情況，比如傳入標簽名和屬性，就會創建一個標簽的虛擬節點，傳入組件名和屬性，就會創建一個組件的虛擬節點。
h()接收三個參數(要渲染的dom，attrs 對象，子元素)
h()有一個更準確的名稱是 createVnode(),考慮到多次使用，一個簡短的名字會更省力。
import { h } from 'vue'
// 使用 h 創建普通標簽
const vnode1=h('div', { class: 'bar', innerHTML: 'hello' })
// vnode1 等同于 <div class="bar">hello</div>
// 使用 h 創建組件
const vnode2=h(myComponent, {
//組件的屬性
title: '測試'
})
// vnode2 等同于 <myComponent title="測試"/>
render()接收標簽或者組件的 vnode，將其渲染成為真實 DOM，并掛載到一個指定的父節點上。
import { h, render } from 'vue'
render(vnode2, document.body)
render(null, document.body) // 當第1個參數為null時，相當于從父節點上移除此組件。
以實現 comfirm 組件為例，具體實現邏輯如下：
<script setup>
import { ref, onMounted } from 'vue'
// 因為將來 confirm 組件是以方法調用的形式展示,所以我們需要手動導入需要使用到的其他通用組件
import mButton from '@/libs/button/index.vue'
const props=defineProps({
// 標題
title: {
type: String
},
// 描述
content: {
type: String,
required: true
},
// 取消按鈕文本
cancelText: {
type: String,
default: '取消'
},
// 確定按鈕文本
confirmText: {
type: String,
default: '確定'
},
// 取消按鈕事件
cancelHandler: {
type: Function
},
// 確定按鈕事件
confirmHandler: {
type: Function
},
// 關閉 confirm 的回調
close: {
type: Function
}
})
// 控制顯示處理
const isVisible=ref(false)
/**
* confirm 展示
*/
const show=()=> {
isVisible.value=true
}
/**
* 處理動畫 (render 函數的渲染，會直接進行)
*/
onMounted(()=> {
show()
})
/**
* 取消事件
*/
const onCancelClick=()=> {
if (props.cancelHandler) {
props.cancelHandler()
}
close()
}
/**
* 確定事件
*/
const onConfirmClick=()=> {
if (props.confirmHandler) {
props.confirmHandler()
}
close()
}
// 關閉動畫處理時間
const duration='0.5s'
/**
* 關閉事件,保留動畫執行時長
*/
const close=()=> {
isVisible.value=false
// 延遲一段時間進行關閉
setTimeout(()=> {
if (props.close) {
props.close()
}
}, parseInt(duration.replace('0.', '').replace('s', '')) * 100)
}
</script>
<template>
<!-- 基于 tailwindcss 創建對應樣式 -->
<div>
<!-- 蒙版 -->
<transition name="fade">
<div
v-if="isVisible"
@click="close"
class="w-screen h-screen bg-zinc-900/80 z-40 fixed left-0 top-0"
></div>
</transition>
<!-- 內容 -->
<transition name="up">
<div
v-if="isVisible"
class="w-[80%] fixed top-1/3 left-[50%] translate-x-[-50%] z-50 px-2 py-1.5 rounded-sm border dark:border-zinc-600 cursor-pointer bg-white dark:bg-zinc-800 xl:w-[35%]"
@click="close"
>
<!-- 標題 -->
<div class="text-lg font-bold text-zinc-800 dark:text-zinc-200 mb-2">{{ title }}</div>
<!-- 文本 -->
<div class="text-base tex-zinc-800 dark:text-zinc-200 mb-2">{{ content }}</div>
<!-- 按鈕 -->
<div class="flex justify-end">
<m-button type="info" class="mr-2" @click="onCancelClick">{{ cancelText }}</m-button>
<m-button type="primary" @click="onConfirmClick">{{ confirmText }}</m-button>
</div>
</div>
</transition>
</div>
</template>
<style lang="scss" scoped>
.fade-enter-active,
.fade-leave-active {
transition: all v-bind(duration);
}
.fade-enter-from,
.fade-leave-to {
opacity: 0;
}
.up-enter-active,
.up-leave-active {
transition: all v-bind(duration);
}
.up-enter-from,
.up-leave-to {
opacity: 0;
transform: translate3d(-50%, -100%, 0);
}
</style>
import { h, render } from 'vue'
import confirmComponent from './confirm.vue'
/**
* @param {*} title 標題
* @param {*} content 內容
* @param {*} cancelText 取消文本
* @param {*} confirmText 確認文本
*/
export const confirmBox=(title, content, cancelText, confirmText)=> {
return new Promise((resolve, reject)=> {
// 不傳入標題，只傳入內容時
if (title && !content) {
content=title
title=''
}
// 取消按鈕事件
const cancelHandler=()=> {
reject(new Error('取消按鈕點擊'))
}
// 確定按鈕事件
const confirmHandler=()=> {
resolve()
}
// 關閉彈層事件
const close=()=> {
render(null, document.body)
}
// 1. 生成 vnode
const vnode=h(confirmComponent, {
title,
content,
cancelText,
confirmText,
cancelHandler,
confirmHandler,
close
})
// 2. render 渲染
render(vnode, document.body)
})
}
import { confirmBox } from './confirm.js'
const onDeleteAllClick=()=> {
confirmBox('要刪除所有歷史記錄嗎？').then(()=> {
// 點擊確定后執行事件
...
})
.catch(()=>{
// 點擊取消后執行事件
...
})
}
作者：LZR
鏈接：https://juejin.cn/post/7320435287297245236
，大家好，我是雷工。
今天學習JavaScript基礎語法，輸入輸出語法，以下為學習筆記。
1.1、alert（）
作用：界面彈出警告對話框。
示例：
<script>
alert（‘要輸出的內容’）
</script>注意：
JavaScript輸出消息時，為了保證程序能夠正常執行，推薦將所有的信息都加引號，單引號雙引號均可以。
1.2、document.write()
作用：向網頁的body標簽內輸出內容。
示例：
<script>
document.write(‘要輸出的內容’)
</script>注意：假如輸出的內容寫的是標簽，也會被解析成網頁元素。
1.3、console.log()
作用：控制臺輸出語法，程序猿調試的時候使用。
示例：
<script>
console.log(‘要輸出的內容’)
</script>2、輸入語法：
2.1、promt()
語法：promt(‘請輸入您的性別：’)
作用：顯示一個對話框，對話框中包含一條提示信息，用來提示用戶輸入信息
展示：
2.2、confirm（）
作用：選擇輸入。
示例：
<script>
confirm（“確定要關注雷工筆記嗎？”）
</script>效果展示：
3、JavaScript代碼執行順序
3.1、按HTML文檔的前后順序執行JavaScript代碼。
3.2、alert（）和prompt（）執行時會跳過界面渲染先被執行。
4、JavaScript語法注意事項
4.1、JavaScript中是嚴格區分字母大小寫的。
4.2、如果想要在網頁中輸出一個HTML標簽，可以通過document.write()
5、后記
以上為JavaScript基礎語法，輸入輸出語法的學習筆記，有錯誤之處歡迎指正。
俗話說：生命在于折騰，生命不息，折騰不止。當然也不要瞎折騰，要為了生活和世界能變得更美好而折騰。
Django的簡單認證系統，后期會分享一些對象級別的權限校驗。
這篇文檔解釋默認配置下Django認證系統的使用。這些配置已經逐步可以滿足大部分常見項目的需要，可以處理范圍非常廣泛的任務，且具有一套細致的密碼和權限實現。對于需要與默認配置不同需求的項目，Django支持擴展和自定義認證。
Django的認證同時提供認證和授權，并通常統一稱為認證系統，因為這些功能某些地方是耦合的。
User對象是認證系統的核心。它們通常表示與你的站點進行交互的用戶，并用于啟用限制訪問、注冊用戶信息和給創建者關聯內容等。在Django的認證框架中只存在一種類型的用戶，因此諸如‘superusers‘或管理員‘staff‘用戶只是具有特殊屬性集的user對象，而不是不同類型的user對象。
默認user的基本屬性有：
完整的參考請參閱完整的API文檔，以下的內容更偏重特定的任務。
創建users最直接的方法是使用create_user()輔助函數：
>>> from django.contrib.auth.models import User
>>> user=User.objects.create_user(‘laowang‘, ‘laowang@thebeatles.com‘, ‘laowangpassword‘)
# At this point, user is a User object that has already been saved
# to the database. You can continue to change its attributes
# if you want to change other fields.
>>> user.last_name=‘Lio‘
>>> user.save()如果你已經安裝了Django admin，你也可以交互式地創建users.
使用createsuperuser命令創建superusers：
$ python manage.py createsuperuser --username=laowang --email=laowang@example.com將會提示你輸入一個密碼。在你輸入一個密碼后，該user將會立即創建。如果不帶--username和--email選項，將會提示你輸入這些值。
Django不會在user模型上存儲原始的（明文）密碼，而只是一個哈希（完整的細節參見文檔：密碼是如何管理的）。因為這個原因，不要嘗試直接操作user的password屬性。這也是為什么創建一個user時要使用輔助函數。
若要修改一個用戶的密碼，你有幾種選擇：
manage.py changepassword *username*提供一種從命令行修改User密碼的方法。它提示你修改一個給定user的密碼，你必須輸入兩次。如果它們匹配，新的密碼將會立即修改。如果你沒有提供user，命令行將嘗試修改與當前系統用戶匹配的用戶名的密碼。
你也可以通過程序修改密碼，使用set_password()：
>>> from django.contrib.auth.models import User
>>> u=User.objects.get(username=‘laowang‘)
>>> u.set_password(‘new password‘)
>>> u.save()如果你安裝了Django admin，你還可以在認證系統的admin頁面修改user的密碼。
Django還提供views和forms用于允許user修改他們自己密碼。
New in Django 1.7.
如果啟用了SessionAuthenticationMiddleware，修改user的密碼將會登出他們所有的會話。 詳細信息請參閱密碼修改后會話失效。
authenticate(**credentials)[source]?
請使用authenticate()，認證一組給定的用戶名和密碼。它接收關鍵字參數形式的憑證，使用默認配置時參數是username和password，如果密碼能夠匹配給定的用戶名，它將返回一個User對象。如果密碼無效，authenticate()返回None。例子：
from django.contrib.auth import authenticate
user=authenticate(username=‘laowang‘, password=‘secret‘)
if user is not None: # the password verified for the user
if user.is_active:
print("User is valid, active and authenticated")
else: print("The password is valid, but the account has been disabled!")
else: # the authentication system was unable to verify the username and password
print("The username and password were incorrect.")注意:
這是認證一系列憑證的低級的方法；例如，它被RemoteUserMiddleware使用。除非你正在編寫你自己的認證系統，否則你可能不會使用到它。當然如果你在尋找一種登錄user的方法，請參見login_required()裝飾器。
Django本身提供了一個簡單的權限系統。它提供一種分配權限給特定的用戶和用戶組的方法。
它被Django的admin站點使用，但歡迎你在你自己的代碼中使用。
Django admin 站點使用如下的權限：
權限不但可以根據每個對象的類型，而且可以根據特定的對象實例設置。通過使用ModelAdmin類提供的has_add_permission()、has_change_permission()和has_delete_permission()方法，可以針對相同類型的不同對象實例自定義權限。
User對象具有兩個多對多的字段：groups和user_permissions。User對象可以用和其它Django 模型一樣的方式訪問它們相關的對象：
myuser.groups=[group_list]
myuser.groups.add(group, group, ...)
myuser.groups.remove(group, group, ...)
myuser.groups.clear()
myuser.user_permissions=[permission_list]
myuser.user_permissions.add(permission, permission, ...)
myuser.user_permissions.remove(permission, permission, ...)
myuser.user_permissions.clear()當django.contrib.auth在你的INSTALLED_APPS設置中列出時，它將確保為你安裝的應用中的每個Django模型創建3個默認的權限 – add、change和delete。
這些權限將在你運行manage.py migrate時創建；在添加django.contrib.auth到INSTALLED_APPS中之后，當你第一次運行migrate時，將會為之前安裝的模型創建默認的權限，包括與此同時正在安裝的新的模型。之后，每當你運行manage.py migrate時，它都將為新的模型創建默認的權限。
假設你有個app_label叫做foo的應用，這個應用有一個名為Bar的模型，要測試基本的權限，你應該使用：
add: user.has_perm(‘foo.add_bar‘)
change: user.has_perm(‘foo.change_bar‘)
delete: user.has_perm(‘foo.delete_bar‘)很少直接訪問Permission模型。
django.contrib.auth.models.Group模型是用戶分類的一種通用的方式，通過這種方式你可以應用權限或其它標簽到這些用戶。一個用戶可以屬于任意多個組。
組中某個用戶自動具有賦給那個組的權限。例如，如果組Site editors具有權限 can_edit_home_page，那么該組中的任何用戶都具有該權限。
除權限之外，組還是給用戶分類的一種方便的方法以給他們某些標簽或擴展的功能。例如，你可以創建一個組‘Special users‘，然后你可以這樣寫代碼，給他們訪問你的站點僅限會員的部分，或者給他們發僅限于會員的郵件。
雖然自定義的權限可以定義在模型的Meta類中，你還可以直接創建權限。例如，你可以為myapp中的BlogPost 創建can_publish權限：
from myapp.models import BlogPost
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
content_type=ContentType.objects.get_for_model(BlogPost)
permission=Permission.objects.create(codename=‘can_publish‘,
name=‘Can Publish Posts‘,
content_type=content_type)然后該權限可以通過user_permissions屬性分配給一個User，或者通過permissions屬性分配給Group。
ModelBackend在第一次需要訪問User對象來檢查權限時會緩存它們的權限。這對于請求-響應循環還是比較好的，因為在權限添加進來之后并不會立即檢查（例如在admin中）。如果你正在添加權限并需要立即檢查它們，例如在一個測試或視圖中，最簡單的解決辦法是從數據庫中重新獲取User。 例如：
from django.contrib.auth.models import Permission, User
from django.shortcuts import get_object_or_404
def user_gains_perms(request, user_id):
user=get_object_or_404(User, pk=user_id)
# any permission check will cache the current set of permissions
user.has_perm(‘myapp.change_bar‘)
permission=Permission.objects.get(codename=‘change_bar‘)
user.user_permissions.add(permission)
# Checking the cached permission set
user.has_perm(‘myapp.change_bar‘) # False
# Request new instance of User
user=get_object_or_404(User, pk=user_id)
# Permission cache is repopulated from the database
user.has_perm(‘myapp.change_bar‘) # TrueDjango使用會話和中間件來攔截request 對象到認證系統中。
它們在每個請求上提供一個request.user屬性，表示當前的用戶。如果當前的用戶沒有登入，該屬性將設置成AnonymousUser的一個實例，否則它將是User的實例。
你可以通過is_authenticated()區分它們，像這樣：
if request.user.is_authenticated():
# Do something for authenticated users. ...
else:
# Do something for anonymous users. ...如果你有一個認證了的用戶，你想把它附帶到當前的會話中 - 這可以通過login()函數完成。
login()[source]?
從視圖中登入一個用戶，請使用login()。它接受一個HttpRequest對象和一個User對象。login()使用Django的session框架來將用戶的ID保存在session中。
注意任何在匿名會話中設置的數據都會在用戶登入后的會話中都會記住。
下面的示例向你演示如何使用authenticate() 和login()：
from django.contrib.auth import authenticate, login
def my_view(request):
username=request.POST[‘username‘]
password=request.POST[‘password‘]
user=authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
# Redirect to a success page.
else:
# Return a ‘disabled account‘ error message
...
else:
# Return an ‘invalid login‘ error message.
...先調用authenticate()：
當你是手工登入一個用戶時，你必須在調用login()之前通過authenticate()成功地認證該用戶。authenticate()在用戶上設置一個屬性，注意哪個認證后端成功驗證了該用戶（有關詳細信息，請參閱后端文檔），以及此信息以后在登錄過程中需要。如果你試圖登入一個直接從數據庫中取出的用戶，將會拋出一個錯誤。
logout()[source]?
若要登出一個已經通過django.contrib.auth.login()登入的用戶，可以在你的視圖中使用django.contrib.auth.logout()。 它接收一個HttpRequest對象且沒有返回值。例如：
from django.contrib.auth import logout
def logout_view(request):
logout(request) # Redirect to a success page.注意，即使用戶沒有登入，logout()也不會拋出任何錯誤。
當你調用logout()時，當前請求的會話數據將被完全清除。所有存在的數據都將清除。這是為了防止另外一個人使用相同的Web瀏覽器登入并訪問前一個用戶的會話數據。如果你想在用戶登出之后>可以立即訪問放入會話中的數據，請在調用django.contrib.auth.logout()之后放入。
原始的方法
限制頁面訪問的簡單、原始的方法是檢查request.user.is_authenticated()并重定向到一個登陸頁面：
from django.conf import settings
from django.shortcuts import redirect
def my_view(request):
if not request.user.is_authenticated():
return redirect(‘%s?next=%s‘ % (settings.LOGIN_URL, request.path))
# ......或者顯示一個錯誤信息：
from django.shortcuts import render
def my_view(request):
if not request.user.is_authenticated():
return render(request, ‘myapp/login_error.html‘)
# ...login_required 裝飾器
login_required([redirect_field_name=REDIRECT_FIELD_NAME, login_url=None])[source]?
作為一個快捷方式，你可以使用便捷的login_required()裝飾器：
from django.contrib.auth.decorators import login_required
@login_required
def my_view(request):
...login_required()完成下面的事情：
默認情況下，在成功認證后用戶應該被重定向的路徑存儲在查詢字符串的一個叫做"next"的參數中。如果對該參數你傾向使用一個不同的名字，login_required()帶有一個可選的redirect_field_name參數：
from django.contrib.auth.decorators import login_required
@login_required(redirect_field_name=‘my_redirect_field‘)
def my_view(request):
...注意，如果你提供一個值給redirect_field_name，你非常可能同時需要自定義你的登錄模板，因為存儲重定向路徑的模板上下文變量將使用redirect_field_name值作為它的鍵，而不是默認的"next"。
login_required()還帶有一個可選的login_url參數。例如：
from django.contrib.auth.decorators import login_required
@login_required(login_url=‘/accounts/login/‘)
def my_view(request):
...注意，如果你沒有指定login_url參數，你需要確保settings.LOGIN_URL與你的登錄視圖正確關聯。例如，使用默認值，可以添加下面幾行到你的URLconf中：
from django.contrib.auth import views as auth_views
url(r‘^accounts/login/$‘, auth_views.login),settings.LOGIN_URL同時還接收視圖函數名和命名的URL模式。這允許你自由地重新映射你的URLconf中的登錄視圖而不用更新設置。
注
login_required裝飾器不檢查user的is_active標志位。
基于特定的權限和其他方式來限制訪問，你最好按照前面描述的那樣操作。
簡單的方法就是在視圖中直接運行你對request.user的測試。例如，視圖檢查用戶的郵件屬于特定的地址（例如@example.com），若不是，則重定向到登錄頁面。
from django.shortcuts import redirect
def my_view(request):
if not request.user.email.endswith(‘@example.com‘):
return redirect(‘/login/?next=%s‘ % request.path)
# ...
user_passes_test(func[, login_url=None, redirect_field_name=REDIRECT_FIELD_NAME])[source]?你可以用方便的 user_passes_test 裝飾器，當回調函數返回 False 時會執行一個重定向操作：
from django.contrib.auth.decorators import user_passes_test
def email_check(user):
return user.email.endswith(‘@example.com‘)
@user_passes_test(email_check)
def my_view(request):
...user_passes_test() 要求一個以User 對象為參數的回調函數，若用戶允許訪問此視圖，返回 True。注意，user_passes_test() 不會自動檢查 User 是否為匿名對象。
user_passes_test()接收兩個額外的參數：
login_url
讓你指定那些沒有通過檢查的用戶要重定向至哪里。若不指定其值，它可能是默認的 settings.LOGIN_URL。
redirect_field_name
與login_required()的參數相同。把它設置為 None 來把它從 URL 中移除，當你想把通不過檢查的用戶重定向到沒有next page 的非登錄頁面時。
例如：
@user_passes_test(email_check, login_url=‘/login/‘) def my_view(request): ...permission_required(perm[, login_url=None, raise_exception=False])[source]?
檢查一個用戶是否有指定的權限是相對常見的需求。因此，Django 提供了一個快捷方式： permission_required() 裝飾器：
from django.contrib.auth.decorators import permission_required
@permission_required(‘polls.can_vote‘)
def my_view(request):
...has_perm() 方法, 權限名稱采用如下方法 "<app label>.<permission codename>" (例如 polls.can_vote表示在 polls 應用下一個模塊的權限。
要注意permission_required() 也接受一個可選的login_url參數。例如：
from django.contrib.auth.decorators import permission_required
@permission_required(‘polls.can_vote‘, login_url=‘/loginpage/‘)
def my_view(request):
...在 login_required() 裝飾器中， login_url默認為settings.LOGIN_URL。
如果提供了 raise_exception 參數，裝飾器拋出PermissionDenied異常，使用 the 403 (HTTP Forbidden) 視圖而不是重定向到登錄頁面。
Changed in Django 1.7:
permission_required()裝飾器既可以接收一個權限序列也可以接收一個單個的權限。
若要對一個基于類的普通視圖使用權限，可以在該類上裝飾View.dispatch方法。詳細細節參見Decorating the class。 另外一個方法是編寫一個封裝as_view()的mixin。
密碼更改后的會話失效
New in Django 1.7.
警告
這種保護只在MIDDLEWARE_CLASSES中SessionAuthenticationMiddleware開啟的情況下應用。如果settings.py由Django ≥ 1.7. 的startproject生成，它會被包含進來。
會話驗證在Django 2.0中將變成強制性的， 無論是否開啟SessionAuthenticationMiddleware 。 如果你擁有一個1.7之前的項目，或者使用不包含SessionAuthenticationMiddleware的模板生成的項目，考慮在閱讀下面的升級說明之后開啟它。
如果你的AUTH_USER_MODEL繼承自AbstractBaseUser，或者實現了它自己的get_session_auth_hash()方法，驗證后的會話會包含這個函數返回的哈希值。在AbstractBaseUser的情況中，這是密碼字段的HMAC。如果開啟了SessionAuthenticationMiddleware ，Django會驗證每個請求帶有的哈希值是否匹配服務端計算出來的哈希值。這允許用戶通過修改密碼來登出所有的會話。
Django中包含的默認的密碼修改視圖，以及django.contrib.auth中的 django.contrib.auth.views.password_change()和user_change_password視圖 ，會使用新的密碼哈希值升級會話，以便用戶在修改密碼時不會登出。如果你擁有自定義的密碼修改視圖，并且希望具有相似的行為，使用這個函數：
update_session_auth_hash(request, user)這個函數接受當前請求，并且會在會話哈希值得到的地方升級用戶對象，也會適當地升級會話哈希值。使用示例：
from django.contrib.auth import update_session_auth_hash
def password_change(request):
if request.method==‘POST‘:
form=PasswordChangeForm(user=request.user, data=request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(request, form.user)
else:
...如果你在升級一個現存的站點，并且希望開啟這一中間件，而不希望你的所有用戶之后重新登錄，你可以首先升級到DJango1.7并且運行它一段時間，以便所有會話在用戶登錄時自然被創建，它們包含上面描述的會話哈希。一旦你使用SessionAuthenticationMiddleware開始運行你的站點，任何沒有登錄并且會話使用驗證哈希值升級過的用戶的現有會話都會失效，并且需要重新登錄。
注意
雖然get_session_auth_hash()基于SECRET_KEY，使用新的私鑰升級你的站點會使所有現有會話失效。
Django 提供一些視圖，你可以用來處理登錄、登出和密碼管理。它們使用內建的認證表單，但你也可以傳遞你自己的表單。
Django 沒有為認證視圖提供默認的模板。你應該為你想要使用的視圖創建自己的模板。模板的上下文定義在每個視圖中，參見所有的認證視圖.
使用視圖
有幾種不同的方法在你的項目中使用這些視圖。最簡單的方法是包含django.contrib.auth.urls 中提供的URLconf到你自己的URLconf中，例如
urlpatterns=[ url(‘^‘, include(‘django.contrib.auth.urls‘)) ]這將包含進下面的URL模式：
^login/$ [name=‘login‘]
^logout/$ [name=‘logout‘]
^password_change/$ [name=‘password_change‘]
^password_change/done/$ [name=‘password_change_done‘]
^password_reset/$ [name=‘password_reset‘]
^password_reset/done/$ [name=‘password_reset_done‘]
^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$ [name=‘password_reset_confirm‘]
^reset/done/$ [name=‘password_reset_complete‘]這些視圖提供了一個簡單易記的URL名稱。使用命名URL模式的細節請參見URL文檔。
如果你想更多地控制你的URL，你可以在你的URLconf中引用一個特定的視圖：
urlpatterns=[ url(‘^change-password/‘, ‘django.contrib.auth.views.password_change‘) ]這些視圖具有可選的參數，你可以用來改變視圖的行為。例如，如果你想修改一個視圖使用的模板名稱，你可以提供template_name 參數。一種方法是在URLconf 中提供關鍵字參數，它們將被傳遞到視圖中。例如：
urlpatterns=[
url(
‘^change-password/‘,
‘django.contrib.auth.views.password_change‘,
{‘template_name‘: ‘change-password.html‘}
)
]所有的視圖都返回一個TemplateResponse 實例，這讓你在渲染前自定義響應很容易。一種方法是在你自己的視圖中封裝一個視圖：
from django.contrib.auth import views
def change_password(request):
template_response=views.password_change(request)
# Do something with `template_response`
return template_response更多的細節，參見TemplateResponse文檔。
下面列出了django.contrib.auth提供的所有視圖。實現細節參見使用視圖。
login(request[, template_name, redirect_field_name, authentication_form, current_app, extra_context])[source]?
URL 名稱： login
關于使用命名URL模式的細節參見URL 文檔。
可選的參數：
下面是django.contrib.auth.views.login所做的事情：
你需要提供html模板給login，默認調用registration/login.html。模板會得到4個模板上下文變量：
如果你不喜歡調用registration/login.html，你可以通過額外的參數傳遞template_name參數給你URLconf中的視圖。例如，下面URLconf中的行將使用myapp/login.html：
url(r‘^accounts/login/$‘, auth_views.login, {‘template_name‘: ‘myapp/login.html‘}),
通過傳遞redirect_field_name給視圖，你還可以指定GET字段的值，它包含登入成功后的重定向的URL。默認情況下，該字段叫做next。
下面是一個registration/login.html模板的示例，你可以用它來作為起點。它假設你有一個定義了content塊的base.html模板：
{% extends "base.html" %}
{% block content %}
{% if form.errors %}
<p>Your username and password didn‘t match. Please try again.</p>
{% endif %}
<form method="post" action="{% url ‘django.contrib.auth.views.login‘ %}">
{% csrf_token %}
<table>
<tr>
<td>{{ form.username.label_tag }}</td>
<td>{{ form.username }}</td>
</tr>
<tr>
<td>{{ form.password.label_tag }}</td>
<td>{{ form.password }}</td>
</tr>
</table>
<input type="submit" value="login" />
<input type="hidden" name="next" value="{{ next }}" />
</form>
{% endblock %}如果你自定義認證（參見Customizing Authentication），你可以通過authentication_form參數傳遞一個自定義的認證表單給登錄視圖。該表單必須在它的__init__方法中接收一個request關鍵字參數，并提供一個get_user方法，此方法返回認證過的用戶對象（這個方法永遠只在表單驗證成功后調用）。
logout(request[, next_page, template_name, redirect_field_name, current_app, extra_context])[source]?
登出一個用戶。
URL名稱： logout
可選的參數：
logout_then_login(request[, login_url, current_app, extra_context])[source]?
登出一個用戶，然后重定向到登錄頁面。
URL 名稱： 沒有提供默認的URL
可選的參數：
password_change(request[, template_name, post_change_redirect, password_change_form, current_app, extra_context])[source]?
允許一個用戶修改他的密碼。
URL 名稱： password_change
可選的參數：
模板上下文：
password_change_done(request[, template_name, current_app, extra_context])[source]?
這個頁面在用戶修改密碼之后顯示。
URL 名稱： password_change_done
可選參數：
password_reset(request[, is_admin_site, template_name, email_template_name, password_reset_form, token_generator, post_reset_redirect, from_email, current_app, extra_context, html_email_template_name])[source]?
允許用戶通過生成一次性的連接并發送到用戶注冊的郵箱地址中來重置密碼。
如果提供的郵箱地址不在系統中存在，這個視圖不會發送任何郵件，但是用戶也不會收到任何錯誤信息。這會阻止數據泄露給潛在的攻擊者。如果你打算在這種情況提供錯誤信息，你可以繼承PasswordResetForm，并使用password_reset_form 參數。
用無效密碼標記的用戶（參見set_unusable_password()）不允許請求重置密碼，為了防止使用類似于LDAP的外部驗證資源時的濫用。注意它們不會收到任何錯誤信息，因為這會暴露它們的賬戶，也不會發送任何郵件。
URL 名稱： password_reset
可選參數：
New in Django 1.7:
添加了html_email_template_name。
自1.8版起已棄用：is_admin_site參數已被廢棄，將在Django2.0中被移除。
模板上下文：
Email模板上下文：
registration/password_reset_email.html樣例（郵件正文模板）：
Someone asked for password reset for email {{ email }}. Follow the link below: {{ protocol}}://{{ domain }}{% url ‘password_reset_confirm‘ uidb64=uid token=token %}
主題模板使用了同樣的模板上下文。主題必須是單行的純文本字符串。
password_reset_done(request[, template_name, current_app, extra_context])[source]?
這個頁面在向用戶發送重置密碼的郵件后展示。如果password_reset()視圖沒有顯式設置 post_reset_redirectURL，默認會調用這個視圖。
URL名稱： password_reset_done
注意
如果提供的email地址在系統中不存在，用戶未激活，或者密碼不可用，用戶仍然會重定向到這個視圖，但是不會發送郵件。
可選參數：
password_reset_confirm(request[, uidb64, token, template_name, token_generator, set_password_form, post_reset_redirect, current_app, extra_context])[source]?
為輸入新密碼展示表單。
URL名稱： password_reset_confirm
可選參數：
模板上下文：
password_reset_complete(request[, template_name, current_app, extra_context])[source]?
展示一個視圖，它通知用戶密碼修改成功。
URL名稱： password_reset_complete
可選參數：
輔助函數
redirect_to_login(next[, login_url, redirect_field_name])[source]?
重定向到登錄頁面，然后在登入成功后回到另一個URL。
必需的參數：
可選的參數：
內建的表單
如果你不想用內建的視圖，但是又不想編寫針對該功能的表單，認證系統提供了幾個內建的表單，位于django.contrib.auth.forms：
注
內建的驗證表單對它們處理的用戶模型做了特定假設。如果你使用了自定義的用戶模型，可能需要為驗證系統定義你自己的表單。更多信息請見內建驗證表單與自定義用戶模型的使用的文檔。
class AdminPasswordChangeForm[source]?
Admin 站點中使用的表單，用于修改用戶密碼。
接受user作為第一個參數。
class AuthenticationForm[source]?
用于用戶登錄的表單。
接受request 作為第一個參數，它將保存在表單實例中以在子類中使用。
confirm_login_allowed(user)[source]?
New in Django 1.7.
默認情況下，AuthenticationForm 將拒絕is_active 標志為False 的用戶。你可以自定義這個行為來決定哪些用戶可以登錄。方法是使用一個自定義的表單，它子類化AuthenticationForm 并覆蓋confirm_login_allowed 方法。如果給出的用戶不能登錄，這個方法應該引發一個ValidationError。
例如，若要允許所有用戶登錄而不管“is_active”狀態如何：
from django.contrib.auth.forms import AuthenticationForm class AuthenticationFormWithInactiveUsersOkay(AuthenticationForm): def confirm_login_allowed(self, user): pass
或者只允許某些激活的用戶登錄：
class PickyAuthenticationForm(AuthenticationForm): def confirm_login_allowed(self, user): if not user.is_active: raise forms.ValidationError( _("This account is inactive."), code=‘inactive‘, ) if user.username.startswith(‘b‘): raise forms.ValidationError( _("Sorry, accounts starting with ‘b‘ aren‘t welcome here."), code=‘no_b_users‘, ) class PasswordChangeForm[source]
用于用戶修改密碼的表單。
class PasswordResetForm[source]
用于生成并郵件發送重置密碼的一個一次性鏈接的表單。
send_email(subject_template_name, email_template_name, context, from_email, to_email[, html_email_template_name=None])?
New in Django 1.8.
使用這些參數來發送EmailMultiAlternatives?？梢愿采w這個方法，來自定義郵件如何發送給用戶。
參數：
subject_template_name —— 郵件標題的模板。
email_template_name —— 郵件正文的模板。
context —— 傳遞給subject_template、email_template 和html_email_template 的上下文（如果它不為None）。
from_email —— 發信人的地址。
to_email —— 收件人的地址。
html_email_template_name —— HTML 格式的郵件正文的模板；默認為None，這種情況下將發送純文本文件。
默認情況下，save() 方法向context 中添加的變量與password_reset() 向它的郵件上下文傳遞的變量相同。
class SetPasswordForm[source]
允許用戶不輸入舊密碼修改密碼的表單。
class UserChangeForm[source]
Admin 站點中使用的表單，用于修改用戶信息和權限。
class UserCreationForm[source]
用于創建新用戶的表單。
當你使用RequestContext時，當前登入的用戶和它們的權限在模板上下文中可以訪問。
技術細節
技術上講，這些變量只有在你使用RequestContext并啟用了‘django.contrib.auth.context_processors.auth‘上下文處理器時才可以在模板上下文中訪問到。它是默認產生的配置文件。更多信息，參見RequestContext 文檔。
當渲染RequestContext模板時，當前登錄的用戶，可能是User實例或者AnonymousUser實例，會存儲在模板變量{{ user }}中：
{% if user.is_authenticated %} <p>Welcome, {{ user.username }}. Thanks for logging in.</p> {% else %} <p>Welcome, new user. Please log in.</p> {% endif %}如果使用的不是RequestContext，則不可以訪問該模板變量：
當前登錄的用戶的權限存儲在模板變量{{ perms }}中。這是個 django.contrib.auth.context_processors實例的封裝，他是一個對于模板友好的權限代理。
在{{ perms }} 對象中，單一屬性的查找是 User.has_module_perms的代理。如果已登錄的用戶在foo 應用中擁有任何許可，這個例子會顯示 True：
{{ perms.foo }}二級屬性的查找是User.has_perm的代理。如果已登錄的用戶擁有foo.can_vote的許可，這個示例會顯示True：
{{ perms.foo.can_vote }}所以，你可以用模板的{% if %}語句檢查權限：
{% if perms.foo %}
<p>You have permission to do something in the foo app.</p>
{% if perms.foo.can_vote %}
<p>You can vote!</p>
{% endif %}
{% if perms.foo.can_drive %}
<p>You can drive!</p>
{% endif %}
{% else %}
<p>You don‘t have permission to do anything in the foo app.</p>
{% endif %}還可以通過{% if in %}語句查詢權限。例如：
{% if ‘foo‘ in perms %}
{% if ‘foo.can_vote‘ in perms %}
<p>In lookup works, too.</p>
{% endif %}
{% endif %}如果django.contrib.admin和django.contrib.auth這兩個你都安裝了，將可以通過admin方便地查看和管理用戶、組和權限。可以像其它任何Django模型一樣創建和刪除用戶?？梢詣摻ńM，并分配權限給用戶和組。admin中還會保存和顯示對用戶模型編輯的日志。
在admin的主頁，你應該可以在“Auth”部分看到“Users”鏈接。“Add user” 頁面與標準admin頁面不同點在于它要求你在編輯用戶的其它字段之前先選擇一個用戶名和密碼。
另請注意：如果你想使得一個用戶能夠使用Django的admin站點創建其它用戶， 你需要給他添加用戶和修改用戶的權限（例如，"Add user” 和“Change user” 權限）。如果一個賬號具有添加用戶的權限但是沒有權限修改他們，該賬號將不能添加用戶。為什么呢？因為如果你具有添加用戶的權限，你將可以添加超級用戶，這些超級用戶將可以修改其他用戶。所以Django同時要求添加權限和修改權限作為一種輕量的安全措施。
仔細考慮一下你是如何允許用戶管理權限的。如果你賦予了一個非超級用戶編輯用戶的能力，這和給他們超級用戶的權限在最終效果上是一樣的，因為他們將能夠提升他們自己下面的用戶的權限。
用戶密碼不會顯示在admin上（也不會存儲在數據庫中），但是會顯示密碼存儲的細節。 這個信息的顯示中包含一條指向修改密碼表單的鏈接，允許管理員修改用戶的密碼。
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
