PyQt5 உடன் QWebEngineView இல்

Gerald Girard

ஞாயிறு, 20 அக்டோபர், 2024 ’அன்று’ பிற்பகல் 1:38:39

PyQt5 QWebEngineView இல் வெளிப்புற ஜாவாஸ்கிரிப்டை அமைத்தல்

PyQt5 ஐப் பயன்படுத்தும் போது QWebEngineView HTML உள்ளடக்கத்தைக் காண்பிக்க, வெளிப்புற ஜாவாஸ்கிரிப்ட் கோப்புகளை ஒருங்கிணைப்பது சில நேரங்களில் எதிர்பாராத சவால்களை அளிக்கலாம். சரியான பாதைகள் அடையாளம் காணப்படாதபோது அல்லது இணையப்பக்கம் வெளிப்புற ஸ்கிரிப்டை சரியாக ஏற்றாதபோது டெவலப்பர்கள் அடிக்கடி சிக்கல்களை எதிர்கொள்கின்றனர்.

நீங்கள் PyQt5 உடன் பணிபுரிந்து, ஒருங்கிணைக்க முயற்சிக்கிறீர்கள் என்றால் .js கோப்பு மூலம் உங்கள் HTML பக்கத்தில் QWebEngineView, பிரச்சினையின் மூல காரணத்தைப் புரிந்துகொள்வது முக்கியம். பாதைச் சிக்கல்கள் அல்லது தவறான உள்ளமைவுகள் எதுவாக இருந்தாலும், சிறிய விவரங்கள் சரியான ஏற்றத்தைத் தடுக்கலாம்.

இந்தக் கட்டுரையில், ஜாவாஸ்கிரிப்ட் கோப்பை ஒரு HTML பக்கத்திற்குள் ஏற்றுவது எதிர்பார்த்தபடி வேலை செய்யாத ஒரு சந்தர்ப்பத்தை நாங்கள் காண்போம். டெவலப்பரின் சூழல் அமைப்பு மற்றும் CSS மற்றும் JavaScript போன்ற ஆதாரங்களுக்கான பாதைகள் எவ்வாறு கையாளப்படுகின்றன என்பது பகுப்பாய்வு செய்யப்படும்.

இந்த வழிகாட்டியின் முடிவில், இந்த குறிப்பிட்ட சிக்கலுக்கான தீர்வை நீங்கள் புரிந்துகொள்வது மட்டுமல்லாமல், PyQt5 இல் வெளிப்புற கோப்புகளை சரியாக இணைப்பது பற்றிய நுண்ணறிவையும் பெறுவீர்கள். இது உங்கள் வேலை செய்யும் திறனை மேம்படுத்தும் QWebEngineView திறமையாக, ஸ்கிரிப்டுகள் மற்றும் பாணிகளின் சீரான ஒருங்கிணைப்பை உறுதி செய்கிறது.

கட்டளை	பயன்பாட்டின் உதாரணம்
QWebEngineView.setPage()	இந்த முறை ஒரு விருப்பத்தை அமைக்க பயன்படுத்தப்படுகிறது QWebEnginePage க்கான QWebEngineView விட்ஜெட், இணைய பார்வையில் தனிப்பயனாக்கப்பட்ட நடத்தை மற்றும் செயல்பாட்டை அனுமதிக்கிறது.
QWebEngineSettings.LocalContentCanAccessRemoteUrls	இந்த பண்புக்கூறு உள்ளூர் HTML கோப்புகளை தொலைநிலை URL களில் இருந்து வெளிப்புற ஆதாரங்களை (CSS அல்லது JavaScript போன்றவை) ஏற்றுவதற்கு உதவுகிறது, இது உள்ளூர் கோப்புகளில் வெளிப்புற ஸ்கிரிப்ட்களை உட்பொதிக்கும் போது தேவையான அம்சமாகும்.
QUrl.fromLocalFile()	இந்த செயல்பாடு ஒரு உள்ளூர் கோப்பு பாதையை a ஆக மாற்றுகிறது QUrl ஆப்ஜெக்ட், இது உள்ளூர் கோப்பு முறைமையிலிருந்து HTML கோப்புகளை ஏற்றுவதற்கு அவசியம் QWebEngineView.
QWebChannel.registerObject()	பைதான் பின்தளத்திற்கும் ஜாவாஸ்கிரிப்ட் ஃபிரண்டெண்டிற்கும் இடையில் தொடர்பு கொள்ள இணைய சேனலுடன் Qt பொருளைப் பதிவு செய்கிறது. இது பைதான் மற்றும் HTML சூழலுக்கு இடையே நிகழ்நேர தொடர்புகளை செயல்படுத்துகிறது.
ஜின்ஜா2 சூழல்	ஸ்கிரிப்ட்டில், HTML டெம்ப்ளேட்களை மாறும் வகையில் ஏற்றவும் மற்றும் வழங்கவும் ஜின்ஜா2 பயன்படுத்தப்படுகிறது. தி சுற்றுச்சூழல் முறையானது கோப்பு முறைமையிலிருந்து டெம்ப்ளேட்களை ஏற்றுவதற்கான சூழலை உருவாக்குகிறது, இது பைத்தானை HTML இல் டைனமிக் உள்ளடக்கத்தைச் செருக அனுமதிக்கிறது.
QWebEnginePage.profile().clearHttpCache()	இந்த கட்டளை தற்போதைய உலாவி தற்காலிக சேமிப்பை அழிக்கிறது QWebEnginePage, வெளிப்புற ஆதாரங்களின் சமீபத்திய பதிப்பு (ஜாவாஸ்கிரிப்ட் அல்லது CSS போன்றவை) தற்காலிக சேமிப்பு கோப்புகளை நம்பாமல் ஏற்றப்படுவதை உறுதி செய்கிறது.
QWebEngineView.setHtml()	இந்த முறை ஒரு HTML சரத்தை நேரடியாக ஏற்றுகிறது QWebEngineView, பைதான் வார்ப்புருக்களிலிருந்து மாறும் HTML உருவாக்கத்தை அனுமதிக்கிறது, இது ஜாவாஸ்கிரிப்ட் கோப்புகளை ஒருங்கிணைக்கும் போது பயனுள்ளதாக இருக்கும்.
unittest.TestCase.setUp()	இது பைத்தானின் ஒரு பகுதி அலகு சோதனை கட்டமைப்பு. தி அமைவு() ஒவ்வொரு சோதனைக்கும் சோதனை நிலைமைகளைத் தொடங்குவதற்கு முறை பயன்படுத்தப்படுகிறது, அதாவது அமைத்தல் QWebEngineView மற்றும் ஜாவாஸ்கிரிப்ட் ஏற்றுதல் செயல்பாட்டைச் சோதிப்பதற்கான அதன் பக்கம்.
QWebEnginePage()	இந்த வகுப்பு ஒரு இணையப் பக்கத்தைக் குறிக்கிறது QWebEngineView. ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு சிக்கல்களைக் கையாள்வதில் முக்கியமாக இருக்கும் இணைய உள்ளடக்கம் (எ.கா. ஜாவாஸ்கிரிப்ட் தொடர்பு) எவ்வாறு கையாளப்படுகிறது என்பதைத் தனிப்பயனாக்க இது துணைப்பிரிவுகளாக இருக்கலாம்.

QWebEngineView இல் ஜாவாஸ்கிரிப்டைக் கையாளுதல்: முக்கிய தீர்வுகள்

PyQt5 ஐப் பயன்படுத்தி வெளிப்புற ஜாவாஸ்கிரிப்ட் கோப்புகளை ஒரு HTML பக்கத்தில் ஏற்றுவதில் உள்ள சிக்கலைத் தீர்ப்பதை நோக்கமாகக் கொண்ட ஸ்கிரிப்டுகள் வழங்கப்பட்டுள்ளன. QWebEngineView. என்பதை உறுதி செய்வதில்தான் சவால் இருக்கிறது .js HTML ஏற்றப்படும்போது கோப்பு சரியாகக் குறிப்பிடப்பட்டு செயல்படுத்தப்படும். துணைப்பிரிவு மூலம் QWebEnginePage, உள்ளூர் ஆதாரங்களை ஏற்றுதல் மற்றும் பைதான்-ஜாவாஸ்கிரிப்ட் தொடர்பைக் கையாளுதல் உட்பட, சிறந்த தனிப்பயனாக்கம் மற்றும் வலைப் பார்வையின் நடத்தை மீதான கட்டுப்பாட்டை தீர்வு அனுமதிக்கிறது.

இந்த எடுத்துக்காட்டில், HTML மாறும் வகையில் ஏற்றப்படுகிறது QWebEngineView பயன்படுத்தி setHtml() முறை. இந்த முறையானது, ரெண்டர் செய்யப்பட்ட HTML உள்ளடக்கத்தை இணையக் காட்சியில் நேரடியாகச் செலுத்துகிறது, HTML கோப்பில் டைனமிக் கூறுகள் அல்லது ஜாவாஸ்கிரிப்ட் அல்லது CSS போன்ற வெளிப்புற ஸ்கிரிப்ட்களைக் குறிப்பிட வேண்டியிருக்கும் போது இது சிறந்த தேர்வாக இருக்கும். தி QWebChannel மேலும் பதிவு செய்யப்பட்டுள்ளது, பைதான் மற்றும் ஜாவாஸ்கிரிப்ட் இடையே சிக்னல்கள் மற்றும் ஸ்லாட்டுகள் மூலம் தொடர்பை செயல்படுத்துகிறது, இது PyQt5 க்குள் உட்பொதிக்கப்பட்ட ஊடாடும் இணைய பயன்பாடுகளுக்கு முக்கியமானது.

ஒரு முக்கிய அம்சம் பயன்பாடு ஆகும் QWebEngineSettings.LocalContentCanAccessRemoteUrls. வேறு கோப்பகத்தில் சேமிக்கப்பட்ட JavaScript கோப்புகள் போன்ற வெளிப்புற ஆதாரங்களை உள்ளூர் HTML கோப்பு ஏற்ற முடியும் என்பதை இந்த அமைப்பு உறுதி செய்கிறது. இந்த வழக்கில், வெளிப்புற ஜாவாஸ்கிரிப்ட் "addons" கோப்புறையில் அமைந்துள்ளது, மேலும் ஸ்கிரிப்ட் ஒரு உடன் சரியாகக் குறிப்பிடப்படுகிறது. <script> HTML இல் குறிச்சொல். இந்த அமைப்பு இல்லாமல், உள்ளூர் உள்ளடக்கம் தேவையான ஜாவாஸ்கிரிப்டை அணுக முடியாது, இது பிழைகள் அல்லது முழுமையற்ற பக்க ரெண்டரிங்கிற்கு வழிவகுக்கும்.

Jinja2 டெம்ப்ளேட்டிங்கின் பயன்பாடு டெவலப்பர் பைத்தானில் இருந்து உட்செலுத்தப்பட்ட உள்ளடக்கத்துடன் HTML ஐ மாறும் வகையில் உருவாக்க அனுமதிக்கிறது. பயனர் உள்ளீடு அல்லது பிற மாறும் காரணிகளின் அடிப்படையில் HTML ஐ மாற்றியமைக்க வேண்டியிருக்கும் போது இது மிகவும் பயனுள்ளதாக இருக்கும். பயன்படுத்துவதன் மூலம் கோப்பு முறைமை ஏற்றி, HTML டெம்ப்ளேட் கோப்பு முறைமையில் இருந்து ஏற்றப்படுகிறது, இது கட்டமைப்பு பராமரிக்கப்படுவதை உறுதி செய்கிறது, அதே நேரத்தில் உண்மையான உள்ளடக்கம் பைதான் மூலம் உருவாக்கப்படுகிறது. டெம்ப்ளேட்டிங், வள மேலாண்மை மற்றும் ஜாவாஸ்கிரிப்ட் கையாளுதல் ஆகியவற்றின் இந்த கலவையானது ஸ்கிரிப்டை பரந்த அளவிலான பயன்பாடுகளுக்கு நெகிழ்வாக மாற்றுகிறது.

QWebEngineView இல் JavaScript கோப்புகளை ஏற்றுகிறது: பல அணுகுமுறைகள்

இந்த தீர்வு PyQt5 ஐப் பயன்படுத்தி நிரூபிக்கிறது QWebEngineView வெளிப்புற ஜாவாஸ்கிரிப்ட் கோப்புகளை (.js) வலைப்பக்கத்தில் சரியாக ஏற்ற, பாதை தொடர்பான சிக்கல்கள் மற்றும் சரியான அமைப்பை உள்ளடக்கியது.

from PyQt5.QtWebEngineWidgets import QWebEngineView, QWebEnginePage
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from PyQt5.QtCore import QUrl
import os

class WebEngine_PythonTerminal(QWebEnginePage):
    def __init__(self, parent=None):
        super().__init__(parent)
        # Additional methods to handle Python console output

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.web_view = QWebEngineView(self)
        self.web_page = WebEngine_PythonTerminal(self)
        self.web_view.setPage(self.web_page)
        self.web_view.settings().setAttribute(QWebEngineSettings.LocalContentCanAccessRemoteUrls, True)

        # Load the HTML with JS file reference
        base_dir = os.path.abspath(os.path.dirname(__file__))
        file_path = os.path.join(base_dir, 'HomePage/home_page.html')
        self.web_view.setUrl(QUrl.fromLocalFile(file_path))
        self.setCentralWidget(self.web_view)

# Create the application
app = QApplication([])
window = MainWindow()
window.show()
app.exec_()

QWebEngineView இல் முழுமையான பாதைகளுடன் ஜாவாஸ்கிரிப்ட் ஏற்றுதல் சிக்கல்களைக் கையாளுதல்

இந்த அணுகுமுறை ஜாவாஸ்கிரிப்ட் ஏற்றுதல் சிக்கல்களைத் தீர்க்க முழுமையான பாதைகளைப் பயன்படுத்தி ஆராய்கிறது, சரியான டைரக்டரி கட்டமைப்பு நிர்வாகத்தில் கவனம் செலுத்துகிறது மற்றும் PyQt5 இல் வெளிப்புற கோப்புகளை திறமையாக கையாளுகிறது.

from PyQt5.QtWebEngineWidgets import QWebEngineView, QWebEnginePage
from PyQt5.QtCore import QUrl
import os

class WebEnginePage(QWebEnginePage):
    def __init__(self, parent=None):
        super().__init__(parent)

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.web_view = QWebEngineView(self)
        self.web_view.setPage(WebEnginePage(self))
        self.web_view.settings().setAttribute(QWebEngineSettings.LocalContentCanAccessRemoteUrls, True)

        # Set absolute path to the HTML file
        base_dir = os.path.abspath(os.path.dirname(__file__))
        html_path = os.path.join(base_dir, 'HomePage/home_page.html')
        self.web_view.setUrl(QUrl.fromLocalFile(html_path))

app = QApplication([])
window = MainWindow()
window.show()
app.exec_()

ஜாவாஸ்கிரிப்ட் மூலம் QWebEngineViewக்கான யூனிட் சோதனைகளைச் சேர்த்தல்

இந்த முறையானது PyQt5 இன் QWebEngineView இல் JavaScript கோப்புகளின் சரியான ஏற்றத்தை சரிபார்ப்பதற்கான அலகு சோதனைகளை எழுதுவதை உள்ளடக்கியது, வெளிப்புற ஆதாரங்கள் சரியாக இணைக்கப்பட்டுள்ளதா என்பதை உறுதி செய்கிறது.

import unittest
from PyQt5.QtWebEngineWidgets import QWebEngineView, QWebEnginePage
from PyQt5.QtCore import QUrl
import os

class TestWebView(unittest.TestCase):
    def setUp(self):
        self.web_page = QWebEnginePage()
        self.web_view = QWebEngineView()
        self.web_view.setPage(self.web_page)

    def test_load_js(self):
        base_dir = os.path.abspath(os.path.dirname(__file__))
        html_path = os.path.join(base_dir, 'HomePage/home_page.html')
        self.web_view.setUrl(QUrl.fromLocalFile(html_path))
        self.assertTrue(self.web_view.url().isLocalFile())

if __name__ == '__main__':
    unittest.main()

PyQt5 QWebEngineView இல் JavaScript ஏற்றுதலை மேம்படுத்துகிறது

வெளிப்புற JavaScript கோப்புகளை ஏற்றும்போது பிழைகள் மற்றும் விதிவிலக்குகளை எவ்வாறு கையாள்வது என்பது இதுவரை விவாதிக்கப்படாத ஒரு முக்கிய அம்சமாகும். QWebEngineView. PyQt5 க்குள் உட்பொதிக்கப்பட்ட வலைப் பயன்பாடுகளில், JavaScript சரியாக ஏற்றப்படுவதையும், தோல்வியுற்றால் அர்த்தமுள்ள கருத்தை வழங்குவதையும் உறுதி செய்வது அவசியம். ஜாவாஸ்கிரிப்ட் பிழை கையாளும் வழிமுறைகளை நேரடியாக HTML குறியீட்டிற்குள் ஒருங்கிணைப்பதன் மூலம் இதைச் செய்யலாம். ஜாவாஸ்கிரிப்ட் குறியீட்டில் ட்ரை-கேட்ச் பிளாக்கைப் பயன்படுத்துவதன் மூலம், பிழைகளைக் கைப்பற்றி, பைதான் கன்சோலுக்குத் தெரிவிக்கலாம்.

மற்றொரு முக்கிய அம்சம் பாதுகாப்பு. உள்ளூர் HTML கோப்புகளை ரிமோட் ஜாவாஸ்கிரிப்ட் அல்லது CSS கோப்புகளை அணுக அனுமதிப்பதன் மூலம், நம்பத்தகாத அல்லது தீங்கிழைக்கும் உள்ளடக்கத்தை ஏற்றும் அபாயம் ஏற்படலாம். எனவே, வெளிப்புற ஆதாரங்கள் ஏற்றப்படுவதை உறுதிசெய்ய ஒருவர் காசோலைகள் அல்லது பயனர் சரிபார்ப்பைச் செயல்படுத்த வேண்டும் QWebEngineView நம்பகமான மற்றும் பாதுகாப்பானவை. பாதுகாப்பை மேம்படுத்த, PyQt5 இன் அமைப்புகளில் ஜாவாஸ்கிரிப்ட் தேவையில்லாதபோது அதை முடக்கலாம் அல்லது இணையப் பக்கத்திலேயே கடுமையான உள்ளடக்கப் பாதுகாப்புக் கொள்கைகளைச் செயல்படுத்தலாம்.

இறுதியாக, பெரிய அல்லது சிக்கலான வலை பயன்பாடுகளைக் கையாளும் போது செயல்திறன் முக்கியமானது. ஏற்றும் நேரத்தைக் குறைக்க JavaScript கோப்புகளை குறைக்கலாம் மற்றும் சுருக்கலாம், மேலும் தற்காலிக சேமிப்பு வழிமுறைகள் திறம்பட பயன்படுத்தப்பட வேண்டும். உடன் QWebEnginePage, HTTP தற்காலிக சேமிப்பை தொடர்ந்து அழிக்க உங்களுக்கு அணுகல் உள்ளது, இது வளர்ச்சி கட்டங்களில் உதவும், ஆனால் உற்பத்தியில், JavaScript இன் சமீபத்திய பதிப்பு செயல்திறனை சமரசம் செய்யாமல் ஏற்றப்படுவதை உறுதிசெய்ய கேச்சிங் உகந்ததாக இருக்க வேண்டும்.

PyQt5 QWebEngineView இல் JavaScript ஐ ஏற்றுவது பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

PyQt5 இல் உள்ளூர் ஜாவாஸ்கிரிப்ட் கோப்பை எவ்வாறு குறிப்பிடுவது?
PyQt5 இல், பயன்படுத்தவும் QUrl.fromLocalFile() உள்ளூர் கோப்புகளை சரியாகக் குறிப்பிட, பாதை முழுமையானது என்பதை உறுதிப்படுத்துகிறது.
QWebEngineView இல் எனது JavaScript கோப்பு ஏன் ஏற்றப்படவில்லை?
கோப்பு பாதை தவறாக இருந்தால் அல்லது இருந்தால் இந்த சிக்கல் ஏற்படலாம் QWebEngineSettings.LocalContentCanAccessRemoteUrls உண்மை என அமைக்கப்படவில்லை. பாதைகள் சரியாக இருப்பதை உறுதிசெய்து, இந்த அமைப்பை இயக்கவும்.
QWebEngineView இல் ஜாவாஸ்கிரிப்ட் மற்றும் பைதான் இடையே தொடர்பை எவ்வாறு இயக்குவது?
நீங்கள் பயன்படுத்தலாம் QWebChannel பைதான் பொருள்களைப் பதிவுசெய்து, இணையக் காட்சியில் இயங்கும் பைதான் குறியீடு மற்றும் ஜாவாஸ்கிரிப்ட் இடையே ஊடாடுவதை அனுமதிக்கவும்.
PyQt5 இல் உள்ள தொலை URL இலிருந்து JavaScript ஐ ஏற்ற முடியுமா?
ஆம், சரியான பண்புக்கூறுகளை அமைப்பதன் மூலம் ரிமோட் ஜாவாஸ்கிரிப்டை ஏற்ற முடியும் QWebEngineSettings, ஆனால் ரிமோட் ஆதாரம் பாதுகாப்பானது என்பதை உறுதிப்படுத்தவும்.
QWebEngineView இல் JavaScript ஐ ஏற்றும்போது செயல்திறனை மேம்படுத்த சில வழிகள் யாவை?
செயல்திறனை மேம்படுத்த, ஜாவாஸ்கிரிப்ட் கோப்புகளை சுருக்கவும் மற்றும் தற்காலிக சேமிப்பைப் பயன்படுத்தவும். இதைப் பயன்படுத்தி தற்காலிக சேமிப்பை நிர்வகிக்கலாம் QWebEnginePage.profile().clearHttpCache().

PyQt5 இல் ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு பற்றிய இறுதி எண்ணங்கள்

வெளிப்புற JavaScript கோப்புகள் வெற்றிகரமாக ஏற்றப்படுகிறது QWebEngineView உள்ளூர் கோப்பு பாதைகளை சரியான முறையில் கையாளுதல் மற்றும் தேவையான அமைப்புகளை இயக்குவதை உறுதி செய்வது ஆகியவை அடங்கும். போன்ற கருவிகளைப் பயன்படுத்துதல் QWebChannel ஜாவாஸ்கிரிப்ட் மற்றும் பைதான் இடையேயான ஊடாடுதலை அனுமதிக்கிறது.

பிழை கையாளுதல் மற்றும் பாதுகாப்பு முன்னெச்சரிக்கைகள் உள்ளிட்ட சரியான அமைப்புடன், PyQt5 ஆனது டைனமிக் உள்ளடக்கத்துடன் சிக்கலான வலைப்பக்கங்களை திறமையாக கையாள முடியும். இது JavaScript இன் தடையற்ற ஒருங்கிணைப்பை உறுதி செய்கிறது மற்றும் கோப்பு ஏற்றுவதில் சிக்கல்கள் இல்லாமல் டெவலப்பர்கள் பதிலளிக்கக்கூடிய பயன்பாடுகளை உருவாக்க அனுமதிக்கிறது.

PyQt5 இல் ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்புக்கான தொடர்புடைய ஆதாரங்கள்

பயன்படுத்துவது பற்றிய விரிவான நுண்ணறிவுகளை வழங்குகிறது QWebEngineView PyQt5 இல் இணைய உள்ளடக்கத்தை உட்பொதிக்க, பைதான் மற்றும் ஜாவாஸ்கிரிப்ட் தொடர்புடன். Qt ஆவணப்படுத்தல்: QtWebEngine
பயன்படுத்துவதற்கான ஒரு விரிவான வழிகாட்டி QWebChannel PyQt பயன்பாடுகளில் பைதான் மற்றும் ஜாவாஸ்கிரிப்ட் தொடர்புக்கு. PyQt5 QtWebChannel ஆவணப்படுத்தல்
PyQt5 இல் இணைய இயந்திரக் காட்சியை எவ்வாறு அமைப்பது மற்றும் CSS மற்றும் JavaScript போன்ற வெளிப்புற ஆதாரங்களை எவ்வாறு ஏற்றுவது என்பதை விளக்குகிறது. ஸ்டாக் ஓவர்ஃப்ளோ: QWebEngineView அமைப்பு

PyQt5 உடன் QWebEngineView இல் ஜாவாஸ்கிரிப்ட் கோப்புகளை ஒருங்கிணைத்தல்: சரிசெய்தல்