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

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

• सर्वव्यापी जोड wsl कंटाळवाणा आणि अनैसर्गिक.
• वितर्कांमधील Windows पथ नेहमी कार्य करत नाहीत कारण बॅकस्लॅशचा डिरेक्टरी विभाजकांऐवजी एस्केप कॅरेक्टर म्हणून अर्थ लावला जातो.
• वितर्कांमधील Windows पथ WSL मधील संबंधित माउंट पॉइंटमध्ये भाषांतरित केले जात नाहीत.
• उपनाम आणि पर्यावरण व्हेरिएबल्ससह WSL प्रोफाइलमध्ये डीफॉल्ट सेटिंग्जचा आदर केला जात नाही.
• लिनक्स पथ पूर्ण करणे समर्थित नाही.
• आदेश पूर्ण करणे समर्थित नाही.
• युक्तिवाद पूर्ण करणे समर्थित नाही.

परिणामी, लिनक्स कमांड्सना विंडोज अंतर्गत द्वितीय श्रेणीच्या नागरिकांसारखे वागवले जाते - आणि मूळ कमांडपेक्षा वापरणे अधिक कठीण आहे. त्यांचे अधिकार समान करण्यासाठी, सूचीबद्ध समस्यांचे निराकरण करणे आवश्यक आहे.

पॉवरशेल फंक्शन रॅपर्स

पॉवरशेल फंक्शन रॅपर्ससह, आम्ही कमांड कम्प्लिशन जोडू शकतो आणि उपसर्गांची गरज दूर करू शकतो wsl, Windows पथ 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

कमांडचा मूलभूत संच येथे दर्शविला आहे, परंतु तुम्ही कोणत्याही लिनक्स कमांडसाठी फक्त सूचीमध्ये जोडून शेल तयार करू शकता. आपण हा कोड जोडल्यास आपल्या प्रोफाइल पॉवरशेल, या कमांड्स तुम्हाला प्रत्येक पॉवरशेल सेशनमध्ये, नेटिव्ह कमांड्सप्रमाणेच उपलब्ध असतील!

डीफॉल्ट सेटिंग्ज

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

पॉवरशेल प्रदान करते $PSDefaultParameterValues, डीफॉल्ट पॅरामीटर्स परिभाषित करण्यासाठी एक मानक यंत्रणा, परंतु केवळ cmdlets आणि प्रगत कार्यांसाठी. अर्थात, आम्ही आमच्या शेलमधून प्रगत फंक्शन्स करू शकतो, परंतु यामुळे अनावश्यक गुंतागुंत निर्माण होते (उदाहरणार्थ, पॉवरशेल आंशिक पॅरामीटर नावांशी संबंधित आहे (उदाहरणार्थ, -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 तुम्हाला पॉवरशेल वरून बॅश कॉल करण्याची परवानगी देते. जर आम्ही आमच्या पॉवरशेल फंक्शन रॅपर्ससाठी वितर्क पूर्णता नोंदवू शकलो आणि पूर्णता निर्माण करण्यासाठी कॉल बॅश करू शकलो, तर आम्हाला बॅश सारख्याच अचूकतेसह संपूर्ण युक्तिवाद पूर्णत्व मिळेल!

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

प्रत्येक स्वयंपूर्णता मागील युक्तिवादासाठी विशिष्ट मूल्ये पुरवते, कॉन्फिगरेशन डेटा वाचते जसे की WSL कडील ज्ञात होस्ट!

<TAB> पॅरामीटर्समधून सायकल चालवेल. <Ctrl + пробел> सर्व उपलब्ध पर्याय दर्शवेल.

शिवाय, आमच्याकडे आता बॅश स्वयंपूर्णता असल्याने, तुम्ही थेट PowerShell मध्ये Linux पथ स्वयंपूर्ण करू शकता!

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

ज्या प्रकरणांमध्ये बॅश स्वयंपूर्णता कोणतेही परिणाम देत नाही, पॉवरशेल सिस्टम डीफॉल्ट विंडोज पथांवर परत येते. अशा प्रकारे, सराव मध्ये, आपण आपल्या विवेकबुद्धीनुसार दोन्ही मार्ग एकाच वेळी वापरू शकता.

निष्कर्ष

पॉवरशेल आणि डब्ल्यूएसएल वापरून, आम्ही लिनक्स कमांड्स विंडोजमध्ये नेटिव्ह अॅप्लिकेशन्स म्हणून समाकलित करू शकतो. Win32 बिल्ड किंवा लिनक्स युटिलिटी शोधण्याची किंवा लिनक्स शेलवर जाऊन तुमच्या वर्कफ्लोमध्ये व्यत्यय आणण्याची गरज नाही. फक्त WSL स्थापित करा, कॉन्फिगर करा पॉवरशेल प्रोफाइल и आपण आयात करू इच्छित आदेशांची यादी करा! लिनक्स आणि विंडोज कमांड पॅरामीटर्स आणि फाईल पाथसाठी समृद्ध स्वयंपूर्णता ही कार्यक्षमता आहे जी आज मूळ विंडोज कमांड्समध्ये देखील उपलब्ध नाही.

वर वर्णन केलेला संपूर्ण स्त्रोत कोड, तसेच तुमच्या वर्कफ्लोमध्ये समाविष्ट करण्यासाठी अतिरिक्त मार्गदर्शक तत्त्वे उपलब्ध आहेत येथे.

तुम्हाला कोणत्या लिनक्स कमांड्स सर्वात उपयुक्त वाटतात? विंडोजमध्ये काम करताना इतर कोणत्या सामान्य गोष्टी गहाळ आहेत? टिप्पण्यांमध्ये लिहा किंवा GitHub वर!

स्त्रोत: www.habr.com