विंडोज़ डेवलपर्स का एक विशिष्ट प्रश्न: “अभी भी ऐसा क्यों नहीं है <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. चाहे वह शक्तिशाली स्वाइप हो less या परिचित उपकरण grep या sed, विंडोज़ डेवलपर्स अपने दैनिक कार्यों में इन कमांडों तक आसान पहुंच चाहते हैं।

Linux के लिए Windows सबसिस्टम (WSL) ने इस संबंध में एक बड़ा कदम आगे बढ़ाया है। यह आपको विंडोज़ से लिनक्स कमांड को प्रॉक्सी करके कॉल करने की अनुमति देता है wsl.exe (उदाहरण के लिए, wsl ls). हालाँकि यह एक महत्वपूर्ण सुधार है, यह विकल्प कई नुकसानों से ग्रस्त है।

• सर्वव्यापी जोड़ wsl थकाऊ और अप्राकृतिक.
• तर्कों में विंडोज़ पथ हमेशा काम नहीं करते क्योंकि बैकस्लैश को निर्देशिका विभाजक के बजाय एस्केप वर्णों के रूप में व्याख्या किया जाता है।
• तर्कों में विंडोज़ पथों को डब्लूएसएल में संबंधित माउंट बिंदु पर अनुवादित नहीं किया जाता है।
• उपनाम और पर्यावरण चर के साथ WSL प्रोफ़ाइल में डिफ़ॉल्ट सेटिंग्स का सम्मान नहीं किया जाता है।
• Linux पथ पूर्णता समर्थित नहीं है.
• आदेश पूर्णता समर्थित नहीं है.
• तर्क पूर्णता समर्थित नहीं है.

परिणामस्वरूप, लिनक्स कमांड को विंडोज़ के तहत द्वितीय श्रेणी के नागरिकों की तरह माना जाता है - और मूल कमांड की तुलना में उपयोग करना अधिक कठिन होता है। उनके अधिकारों को बराबर करने के लिए सूचीबद्ध समस्याओं का समाधान करना आवश्यक है।

पॉवरशेल फ़ंक्शन रैपर

पॉवरशेल फ़ंक्शन रैपर के साथ, हम कमांड पूर्णता जोड़ सकते हैं और उपसर्गों की आवश्यकता को समाप्त कर सकते हैं wsl, विंडोज़ पथों को डब्लूएसएल पथों में अनुवादित करना। गोले के लिए बुनियादी आवश्यकताएँ:

• प्रत्येक लिनक्स कमांड के लिए समान नाम का एक फ़ंक्शन रैपर होना चाहिए।
• शेल को तर्क के रूप में पारित विंडोज़ पथों को पहचानना होगा और उन्हें डब्लूएसएल पथों में परिवर्तित करना होगा।
• शेल को कॉल करना चाहिए wsl किसी भी पाइपलाइन इनपुट के लिए उपयुक्त लिनक्स कमांड के साथ और फ़ंक्शन में पारित किसी भी कमांड लाइन तर्क को पास करना।

चूँकि यह पैटर्न किसी भी कमांड पर लागू किया जा सकता है, हम इन रैपर्स की परिभाषा को अमूर्त कर सकते हैं और उन्हें आयात करने के लिए कमांड की सूची से गतिशील रूप से उत्पन्न कर सकते हैं।

# The commands to import.
$commands = "awk", "emacs", "grep", "head", "less", "ls", "man", "sed", "seq", "ssh", "tail", "vim"
 
# Register a function for each command.
$commands | ForEach-Object { Invoke-Expression @"
Remove-Alias $_ -Force -ErrorAction Ignore
function global:$_() {
    for (`$i = 0; `$i -lt `$args.Count; `$i++) {
        # If a path is absolute with a qualifier (e.g. C:), run it through wslpath to map it to the appropriate mount point.
        if (Split-Path `$args[`$i] -IsAbsolute -ErrorAction Ignore) {
            `$args[`$i] = Format-WslArgument (wsl.exe wslpath (`$args[`$i] -replace "", "/"))
        # If a path is relative, the current working directory will be translated to an appropriate mount point, so just format it.
        } elseif (Test-Path `$args[`$i] -ErrorAction Ignore) {
            `$args[`$i] = Format-WslArgument (`$args[`$i] -replace "", "/")
        }
    }
 
    if (`$input.MoveNext()) {
        `$input.Reset()
        `$input | wsl.exe $_ (`$args -split ' ')
    } else {
        wsl.exe $_ (`$args -split ' ')
    }
}
"@
}

सूची $command आयात आदेशों को परिभाषित करता है। फिर हम कमांड का उपयोग करके उनमें से प्रत्येक के लिए गतिशील रूप से एक फ़ंक्शन रैपर उत्पन्न करते हैं Invoke-Expression (पहले ऐसे किसी भी उपनाम को हटाकर जो फ़ंक्शन के साथ विरोध करेगा)।

फ़ंक्शन कमांड लाइन तर्कों पर पुनरावृत्त होता है, कमांड का उपयोग करके विंडोज पथ निर्धारित करता है Split-Path и Test-Pathऔर फिर इन पथों को WSL पथों में परिवर्तित करता है। हम एक सहायक फ़ंक्शन के माध्यम से पथ चलाते हैं Format-WslArgument, जिसे हम बाद में परिभाषित करेंगे। यह रिक्त स्थान और कोष्ठक जैसे विशेष वर्णों से बच जाता है जिनकी अन्यथा गलत व्याख्या की जाएगी।

अंत में, हम बताते हैं wsl पाइपलाइन इनपुट और कोई कमांड लाइन तर्क।

इन रैपर्स के साथ आप बिना किसी उपसर्ग को जोड़े अपने पसंदीदा लिनक्स कमांड को अधिक प्राकृतिक तरीके से कॉल कर सकते हैं wsl और इस बात की चिंता किए बिना कि पथ कैसे परिवर्तित होते हैं:

• man bash
• less -i $profile.CurrentUserAllHosts
• ls -Al C:Windows | less
• grep -Ein error *.log
• tail -f *.log

कमांड का मूल सेट यहां दिखाया गया है, लेकिन आप इसे सूची में जोड़कर किसी भी लिनक्स कमांड के लिए एक शेल बना सकते हैं। यदि आप इस कोड को अपने में जोड़ते हैं प्रोफ़ाइल पॉवरशेल, ये कमांड आपके लिए प्रत्येक पॉवरशेल सत्र में उपलब्ध होंगे, बिल्कुल मूल कमांड की तरह!

न्यूनता समायोजन

लिनक्स में, लॉगिन प्रोफाइल में उपनाम और/या पर्यावरण चर को परिभाषित करना, अक्सर उपयोग किए जाने वाले कमांड के लिए डिफ़ॉल्ट पैरामीटर सेट करना आम बात है (उदाहरण के लिए, alias ls=ls -AFh या export LESS=-i). गैर-संवादात्मक शेल के माध्यम से प्रॉक्सी करने के नुकसानों में से एक wsl.exe - कि प्रोफ़ाइल लोड नहीं हुई हैं, इसलिए ये विकल्प डिफ़ॉल्ट रूप से उपलब्ध नहीं हैं (अर्थात ls डब्ल्यूएसएल में और wsl ls ऊपर परिभाषित उपनाम के साथ अलग व्यवहार करेगा)।

पॉवरशेल प्रदान करता है $PSDefaultParameterValues, डिफ़ॉल्ट मापदंडों को परिभाषित करने के लिए एक मानक तंत्र, लेकिन केवल सीएमडीलेट्स और उन्नत कार्यों के लिए। बेशक, हम अपने शेल से उन्नत फ़ंक्शन बना सकते हैं, लेकिन यह अनावश्यक जटिलताओं का परिचय देता है (उदाहरण के लिए, पावरशेल आंशिक पैरामीटर नामों को सहसंबंधित करता है (उदाहरण के लिए, -a के साथ संबंध रखता है -ArgumentList), जो लिनक्स कमांड के साथ संघर्ष करेगा जो आंशिक नाम को तर्क के रूप में लेते हैं), और डिफ़ॉल्ट मानों को परिभाषित करने के लिए वाक्यविन्यास सबसे उपयुक्त नहीं होगा (डिफ़ॉल्ट तर्क के लिए कुंजी में पैरामीटर के नाम की आवश्यकता होती है, न कि केवल कमांड नाम की) .

हालाँकि, अपने शेल्स में थोड़े से संशोधन के साथ, हम इसके समान एक मॉडल लागू कर सकते हैं $PSDefaultParameterValues, और Linux कमांड के लिए डिफ़ॉल्ट विकल्प सक्षम करें!

function global:$_() {
    …
 
    `$defaultArgs = ((`$WslDefaultParameterValues.$_ -split ' '), "")[`$WslDefaultParameterValues.Disabled -eq `$true]
    if (`$input.MoveNext()) {
        `$input.Reset()
        `$input | wsl.exe $_ `$defaultArgs (`$args -split ' ')
    } else {
        wsl.exe $_ `$defaultArgs (`$args -split ' ')
    }
}

पासिंग $WslDefaultParameterValues कमांड लाइन पर, हम पैरामीटर भेजते हैं wsl.exe. निम्नलिखित दिखाता है कि डिफ़ॉल्ट सेटिंग्स को कॉन्फ़िगर करने के लिए अपने PowerShell प्रोफ़ाइल में निर्देश कैसे जोड़ें। अब हम यह कर सकते हैं!

$WslDefaultParameterValues["grep"] = "-E"
$WslDefaultParameterValues["less"] = "-i"
$WslDefaultParameterValues["ls"] = "-AFh --group-directories-first"

चूंकि पैरामीटर बाद में मॉडल किए गए हैं $PSDefaultParameterValues, आप कर सकते हैं उन्हें अक्षम करना आसान है कुंजी स्थापित करके अस्थायी रूप से "Disabled" अर्थ में $true. एक अलग हैश तालिका का एक अतिरिक्त लाभ अक्षम करने की क्षमता है $WslDefaultParameterValues से अलग $PSDefaultParameterValues.

तर्क पूर्ण होना

पॉवरशेल आपको कमांड का उपयोग करके तर्क ट्रेलरों को पंजीकृत करने की अनुमति देता है Register-ArgumentCompleter. बैश शक्तिशाली है प्रोग्रामयोग्य स्वतः पूर्णता उपकरण. WSL आपको PowerShell से बैश कॉल करने की अनुमति देता है। यदि हम अपने पावरशेल फ़ंक्शन रैपर के लिए तर्क पूर्णताएं पंजीकृत कर सकते हैं और पूर्णताएं उत्पन्न करने के लिए बैश को कॉल कर सकते हैं, तो हमें बैश के समान सटीकता के साथ पूर्ण तर्क पूर्णता मिलती है!

# Register an ArgumentCompleter that shims bash's programmable completion.
Register-ArgumentCompleter -CommandName $commands -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)
 
    # Map the command to the appropriate bash completion function.
    $F = switch ($commandAst.CommandElements[0].Value) {
        {$_ -in "awk", "grep", "head", "less", "ls", "sed", "seq", "tail"} {
            "_longopt"
            break
        }
 
        "man" {
            "_man"
            break
        }
 
        "ssh" {
            "_ssh"
            break
        }
 
        Default {
            "_minimal"
            break
        }
    }
 
    # Populate bash programmable completion variables.
    $COMP_LINE = "`"$commandAst`""
    $COMP_WORDS = "('$($commandAst.CommandElements.Extent.Text -join "' '")')" -replace "''", "'"
    for ($i = 1; $i -lt $commandAst.CommandElements.Count; $i++) {
        $extent = $commandAst.CommandElements[$i].Extent
        if ($cursorPosition -lt $extent.EndColumnNumber) {
            # The cursor is in the middle of a word to complete.
            $previousWord = $commandAst.CommandElements[$i - 1].Extent.Text
            $COMP_CWORD = $i
            break
        } elseif ($cursorPosition -eq $extent.EndColumnNumber) {
            # The cursor is immediately after the current word.
            $previousWord = $extent.Text
            $COMP_CWORD = $i + 1
            break
        } elseif ($cursorPosition -lt $extent.StartColumnNumber) {
            # The cursor is within whitespace between the previous and current words.
            $previousWord = $commandAst.CommandElements[$i - 1].Extent.Text
            $COMP_CWORD = $i
            break
        } elseif ($i -eq $commandAst.CommandElements.Count - 1 -and $cursorPosition -gt $extent.EndColumnNumber) {
            # The cursor is within whitespace at the end of the line.
            $previousWord = $extent.Text
            $COMP_CWORD = $i + 1
            break
        }
    }
 
    # Repopulate bash programmable completion variables for scenarios like '/mnt/c/Program Files'/<TAB> where <TAB> should continue completing the quoted path.
    $currentExtent = $commandAst.CommandElements[$COMP_CWORD].Extent
    $previousExtent = $commandAst.CommandElements[$COMP_CWORD - 1].Extent
    if ($currentExtent.Text -like "/*" -and $currentExtent.StartColumnNumber -eq $previousExtent.EndColumnNumber) {
        $COMP_LINE = $COMP_LINE -replace "$($previousExtent.Text)$($currentExtent.Text)", $wordToComplete
        $COMP_WORDS = $COMP_WORDS -replace "$($previousExtent.Text) '$($currentExtent.Text)'", $wordToComplete
        $previousWord = $commandAst.CommandElements[$COMP_CWORD - 2].Extent.Text
        $COMP_CWORD -= 1
    }
 
    # Build the command to pass to WSL.
    $command = $commandAst.CommandElements[0].Value
    $bashCompletion = ". /usr/share/bash-completion/bash_completion 2> /dev/null"
    $commandCompletion = ". /usr/share/bash-completion/completions/$command 2> /dev/null"
    $COMPINPUT = "COMP_LINE=$COMP_LINE; COMP_WORDS=$COMP_WORDS; COMP_CWORD=$COMP_CWORD; COMP_POINT=$cursorPosition"
    $COMPGEN = "bind `"set completion-ignore-case on`" 2> /dev/null; $F `"$command`" `"$wordToComplete`" `"$previousWord`" 2> /dev/null"
    $COMPREPLY = "IFS=`$'n'; echo `"`${COMPREPLY[*]}`""
    $commandLine = "$bashCompletion; $commandCompletion; $COMPINPUT; $COMPGEN; $COMPREPLY" -split ' '
 
    # Invoke bash completion and return CompletionResults.
    $previousCompletionText = ""
    (wsl.exe $commandLine) -split 'n' |
    Sort-Object -Unique -CaseSensitive |
    ForEach-Object {
        if ($wordToComplete -match "(.*=).*") {
            $completionText = Format-WslArgument ($Matches[1] + $_) $true
            $listItemText = $_
        } else {
            $completionText = Format-WslArgument $_ $true
            $listItemText = $completionText
        }
 
        if ($completionText -eq $previousCompletionText) {
            # Differentiate completions that differ only by case otherwise PowerShell will view them as duplicate.
            $listItemText += ' '
        }
 
        $previousCompletionText = $completionText
        [System.Management.Automation.CompletionResult]::new($completionText, $listItemText, 'ParameterName', $completionText)
    }
}
 
# Helper function to escape characters in arguments passed to WSL that would otherwise be misinterpreted.
function global:Format-WslArgument([string]$arg, [bool]$interactive) {
    if ($interactive -and $arg.Contains(" ")) {
        return "'$arg'"
    } else {
        return ($arg -replace " ", " ") -replace "([()|])", ('$1', '`$1')[$interactive]
    }
}

बैश के कुछ आंतरिक कार्यों को समझे बिना कोड थोड़ा सघन है, लेकिन मूल रूप से हम जो करते हैं वह यह है:

• एक सूची पारित करके हमारे सभी फ़ंक्शन रैपर्स के लिए एक तर्क पूर्णकर्ता पंजीकृत करना $commands पैरामीटर में -CommandName के लिए Register-ArgumentCompleter.
• हम प्रत्येक कमांड को शेल फ़ंक्शन पर मैप करते हैं जिसका उपयोग बैश स्वत: पूर्णता के लिए करता है (स्वत: पूर्णता विनिर्देशों को परिभाषित करने के लिए, बैश उपयोग करता है $F, के लिए संक्षिप्त रूप complete -F <FUNCTION>).
• पॉवरशेल तर्कों को परिवर्तित करना $wordToComplete, $commandAst и $cursorPosition विनिर्देशों के अनुसार बैश के स्वत: पूर्ण कार्यों द्वारा अपेक्षित प्रारूप में प्रोग्रामयोग्य स्वतः पूर्णता दे घुमा के।
• हम स्थानांतरित करने के लिए एक कमांड लाइन बनाते हैं wsl.exe, जो यह सुनिश्चित करता है कि पर्यावरण सही ढंग से सेट किया गया है, उचित ऑटो-पूर्ण फ़ंक्शन को कॉल करता है, और लाइन-दर-लाइन फैशन में परिणाम आउटपुट करता है।
• फिर हम कॉल करते हैं wsl कमांड लाइन के साथ, हम आउटपुट को लाइन सेपरेटर द्वारा अलग करते हैं और प्रत्येक के लिए जेनरेट करते हैं CompletionResults, उन्हें क्रमबद्ध करना और रिक्त स्थान और कोष्ठक जैसे वर्णों से बचना, जिनकी अन्यथा गलत व्याख्या की जाएगी।

परिणामस्वरूप, हमारे लिनक्स कमांड शेल बैश के समान ही स्वत: पूर्णता का उपयोग करेंगे! उदाहरण के लिए:

• ssh -c <TAB> -J <TAB> -m <TAB> -O <TAB> -o <TAB> -Q <TAB> -w <TAB> -b <TAB>

प्रत्येक स्वत: पूर्णता पिछले तर्क के लिए विशिष्ट मान प्रदान करती है, डब्लूएसएल से ज्ञात होस्ट जैसे कॉन्फ़िगरेशन डेटा को पढ़ती है!

<TAB> मापदंडों के माध्यम से चक्रित होगा। <Ctrl + пробел> सभी उपलब्ध विकल्प दिखाएगा.

साथ ही, चूँकि अब हमारे पास बैश स्वतः पूर्णता है, आप सीधे पॉवरशेल में लिनक्स पथों को स्वतः पूर्ण कर सकते हैं!

• less /etc/<TAB>
• ls /usr/share/<TAB>
• vim ~/.bash<TAB>

ऐसे मामलों में जहां बैश स्वत: पूर्णता कोई परिणाम नहीं देती है, पावरशेल सिस्टम डिफ़ॉल्ट विंडोज पथ पर वापस आ जाता है। इस प्रकार, व्यवहार में, आप अपने विवेक से दोनों रास्तों का एक साथ उपयोग कर सकते हैं।

निष्कर्ष

पॉवरशेल और डब्लूएसएल का उपयोग करके, हम लिनक्स कमांड को विंडोज़ में मूल अनुप्रयोगों के रूप में एकीकृत कर सकते हैं। Win32 बिल्ड या Linux उपयोगिताओं की खोज करने या Linux शेल पर जाकर अपने वर्कफ़्लो को बाधित करने की कोई आवश्यकता नहीं है। अभी डब्लूएसएल स्थापित करें, कॉन्फ़िगर करें पॉवरशेल प्रोफ़ाइल и उन आदेशों को सूचीबद्ध करें जिन्हें आप आयात करना चाहते हैं! लिनक्स और विंडोज कमांड पैरामीटर और फ़ाइल पथों के लिए रिच स्वत: पूर्णता ऐसी कार्यक्षमता है जो आज मूल विंडोज कमांड में भी उपलब्ध नहीं है।

ऊपर वर्णित पूर्ण स्रोत कोड, साथ ही इसे आपके वर्कफ़्लो में शामिल करने के लिए अतिरिक्त दिशानिर्देश उपलब्ध हैं यहां.

आपको कौन सा लिनक्स कमांड सबसे उपयोगी लगता है? विंडोज़ में काम करते समय अन्य कौन सी सामान्य चीज़ें गायब हैं? टिप्पणियों में लिखें या गीथहब पर!

स्रोत: www.habr.com