विन्डोज विकासकर्ताहरूबाट एक सामान्य प्रश्न: "किन त्यहाँ अझै छैन <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?। चाहे यो एक शक्तिशाली स्वाइप हो less वा परिचित उपकरणहरू grep वा sed, Windows विकासकर्ताहरू आफ्नो दैनिक काममा यी आदेशहरूमा सजिलो पहुँच चाहन्छन्।

लिनक्सका लागि विन्डोज सबसिस्टम (WSL) यस सन्दर्भमा ठूलो कदम अघि बढेको छ। यसले तपाइँलाई विन्डोजबाट लिनक्स आदेशहरूलाई प्रोक्सी गरेर कल गर्न अनुमति दिन्छ wsl.exe (जस्तै wsl ls)। यद्यपि यो एक महत्त्वपूर्ण सुधार हो, यो विकल्प धेरै बेफाइदाहरूबाट ग्रस्त छ।

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

नतिजाको रूपमा, लिनक्स आदेशहरू Windows अन्तर्गत दोस्रो-कक्षाका नागरिकहरू जस्तै व्यवहार गरिन्छ - र नेटिभ आदेशहरू भन्दा प्रयोग गर्न गाह्रो हुन्छ। उनीहरूको अधिकारलाई समान बनाउन, सूचीबद्ध समस्याहरू समाधान गर्न आवश्यक छ।

PowerShell प्रकार्य रैपरहरू

PowerShell प्रकार्य र्यापरहरूसँग, हामी कमाण्ड पूरा गर्न र उपसर्गहरूको आवश्यकता हटाउन सक्छौं wsl, WSL पथहरूमा Windows पथहरू अनुवाद गर्दै। गोलाका लागि आधारभूत आवश्यकताहरू:

• प्रत्येक लिनक्स कमाण्डको लागि एउटै नामको एक प्रकार्य र्यापर हुनुपर्छ।
• शेलले तर्कको रूपमा पारित विन्डोज पथहरू पहिचान गर्नुपर्छ र तिनीहरूलाई 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

आदेशहरूको आधारभूत सेट यहाँ देखाइएको छ, तर तपाईले कुनै पनि लिनक्स आदेशको लागि यसलाई सूचीमा थपेर शेल सिर्जना गर्न सक्नुहुन्छ। यदि तपाइँ यो कोड तपाइँको मा थप्नुहुन्छ प्रोफाइल PowerShell, यी आदेशहरू तपाईलाई प्रत्येक PowerShell सत्रमा उपलब्ध हुनेछन्, जस्तै नेटिभ आदेशहरू!

पूर्वनिर्धारित सेटिङहरू

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

PowerShell प्रदान गर्दछ $PSDefaultParameterValues, पूर्वनिर्धारित प्यारामिटरहरू परिभाषित गर्नको लागि मानक संयन्त्र, तर cmdlets र उन्नत प्रकार्यहरूको लागि मात्र। अवश्य पनि, हामी हाम्रा शेलहरूबाट उन्नत प्रकार्यहरू बनाउन सक्छौं, तर यसले अनावश्यक जटिलताहरू परिचय गराउँछ (उदाहरणका लागि, PowerShell आंशिक प्यारामिटर नामहरूसँग सम्बन्धित छ (उदाहरणका लागि, -a संग सम्बन्धित छ -ArgumentList), जुन लिनक्स आदेशहरूसँग विवादित हुनेछ जसले तर्कको रूपमा आंशिक नामहरू लिन्छ), र पूर्वनिर्धारित मानहरू परिभाषित गर्नका लागि सिन्ट्याक्स सबैभन्दा उपयुक्त हुनेछैन (पूर्वनिर्धारित तर्कहरूलाई कुञ्जीमा प्यारामिटरको नाम चाहिन्छ, आदेश नाम मात्र होइन) ।

यद्यपि, हाम्रो गोलाहरूमा थोरै परिमार्जन संग, हामी समान मोडेल लागू गर्न सक्छौं $PSDefaultParameterValues, र लिनक्स आदेशहरूको लागि पूर्वनिर्धारित विकल्पहरू सक्षम गर्नुहोस्!

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.

तर्क समापन

PowerShell ले तपाईंलाई आदेश प्रयोग गरेर तर्क ट्रेलरहरू दर्ता गर्न अनुमति दिन्छ Register-ArgumentCompleter। बाससँग शक्तिशाली छ प्रोग्रामयोग्य स्वत: पूरा गर्ने उपकरण। WSL ले तपाईंलाई PowerShell बाट bash कल गर्न अनुमति दिन्छ। यदि हामीले हाम्रो PowerShell प्रकार्य र्यापरहरूको लागि तर्क पूर्णताहरू दर्ता गर्न सक्छौं र पूराहरू उत्पन्न गर्न bash कल गर्न सक्छौं भने, हामी bash आफैं जस्तै सटीकताका साथ पूर्ण तर्क पूरा हुन्छौं!

# 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]
    }
}

कोड bash को आन्तरिक प्रकार्यहरु को केहि बुझ्न बिना अलि घना छ, तर मूलतः हामी के गर्छौं यो हो:

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

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

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

प्रत्येक स्वत: पूर्णताले अघिल्लो तर्कमा निर्दिष्ट मानहरू आपूर्ति गर्दछ, कन्फिगरेसन डेटा पढ्दै जस्तै WSL बाट ज्ञात होस्टहरू!

<TAB> प्यारामिटरहरू मार्फत चक्र हुनेछ। <Ctrl + пробел> सबै उपलब्ध विकल्पहरू देखाउनेछ।

साथै, हामीसँग अब bash स्वत: पूर्णता भएको हुनाले, तपाईंले PowerShell मा सिधै लिनक्स पथहरू स्वत: पूर्ण गर्न सक्नुहुन्छ!

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

बास स्वत: पूर्णताले कुनै परिणामहरू उत्पादन गर्दैन भने, PowerShell प्रणाली पूर्वनिर्धारित विन्डोज पथहरूमा फर्किन्छ। तसर्थ, अभ्यासमा, तपाइँ एकै साथ तपाइँको विवेकमा दुबै मार्गहरू प्रयोग गर्न सक्नुहुन्छ।

निष्कर्षमा

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

माथि वर्णन गरिएको पूर्ण स्रोत कोड, साथै यसलाई तपाईंको कार्यप्रवाहमा समावेश गर्नका लागि थप दिशानिर्देशहरू उपलब्ध छन् यहाँ.

कुन लिनक्स आदेशहरू तपाईंलाई सबैभन्दा उपयोगी लाग्छ? Windows मा काम गर्दा के अन्य सामान्य चीजहरू हराइरहेका छन्? कमेन्टमा लेख्नुहोस् वा GitHub मा!

स्रोत: www.habr.com