વિન્ડોઝ ડેવલપર્સ તરફથી એક સામાન્ય પ્રશ્ન: “હજુ પણ કેમ નથી <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. ભલે તે શક્તિશાળી સ્વાઇપ હોય less અથવા પરિચિત સાધનો grep અથવા sed, વિન્ડોઝ ડેવલપર્સ તેમના રોજિંદા કામમાં આ આદેશોની સરળ ઍક્સેસ ઇચ્છે છે.

Linux (WSL) માટે વિન્ડોઝ સબસિસ્ટમ આ બાબતે એક મોટું પગલું આગળ વધાર્યું છે. તે તમને વિન્ડોઝમાંથી Linux આદેશોને પ્રોક્સી કરીને કૉલ કરવાની મંજૂરી આપે છે wsl.exe (દા.ત., wsl ls). જો કે આ એક નોંધપાત્ર સુધારો છે, આ વિકલ્પ સંખ્યાબંધ ગેરફાયદાથી પીડાય છે.

• સર્વવ્યાપક ઉમેરો wsl કંટાળાજનક અને અકુદરતી.
• દલીલોમાં વિન્ડોઝ પાથ હંમેશા કામ કરતા નથી કારણ કે બેકસ્લેશને ડિરેક્ટરી વિભાજકને બદલે એસ્કેપ કેરેક્ટર તરીકે અર્થઘટન કરવામાં આવે છે.
• દલીલોમાંના વિન્ડોઝ પાથ WSL માં અનુરૂપ માઉન્ટ પોઈન્ટમાં અનુવાદિત થતા નથી.
• ઉપનામો અને પર્યાવરણ ચલો સાથે WSL પ્રોફાઇલ્સમાં ડિફૉલ્ટ સેટિંગ્સને માન આપવામાં આવતું નથી.
• Linux પાથ પૂર્ણતાને સમર્થન નથી.
• આદેશ પૂર્ણતા સપોર્ટેડ નથી.
• દલીલ પૂર્ણતાને સમર્થન નથી.

પરિણામે, Linux આદેશોને વિન્ડોઝ હેઠળ બીજા-વર્ગના નાગરિકોની જેમ ગણવામાં આવે છે - અને મૂળ આદેશો કરતાં તેનો ઉપયોગ કરવો વધુ મુશ્કેલ છે. તેમના અધિકારોને સમાન બનાવવા માટે, સૂચિબદ્ધ સમસ્યાઓ હલ કરવી જરૂરી છે.

પાવરશેલ ફંક્શન રેપર્સ

પાવરશેલ ફંક્શન રેપર સાથે, અમે કમાન્ડ કમ્પ્લીશન ઉમેરી શકીએ છીએ અને ઉપસર્ગની જરૂરિયાતને દૂર કરી શકીએ છીએ wsl, WSL પાથમાં વિન્ડોઝ પાથનું ભાષાંતર. શેલ માટે મૂળભૂત આવશ્યકતાઓ:

• દરેક Linux આદેશ માટે સમાન નામ સાથે એક ફંક્શન રેપર હોવું આવશ્યક છે.
• શેલે દલીલો તરીકે પસાર કરેલા Windows પાથને ઓળખવા જોઈએ અને તેમને WSL પાથમાં કન્વર્ટ કરવા જોઈએ.
• શેલ કૉલ કરવો જોઈએ wsl કોઈપણ પાઈપલાઈન ઇનપુટ માટે યોગ્ય Linux આદેશ સાથે અને ફંક્શનમાં પસાર થયેલ કોઈપણ આદેશ વાક્ય દલીલો પસાર કરો.

આ પેટર્ન કોઈપણ આદેશ પર લાગુ કરી શકાય છે, તેથી અમે આ રેપર્સની વ્યાખ્યાને અમૂર્ત કરી શકીએ છીએ અને તેમને આયાત કરવા માટેના આદેશોની સૂચિમાંથી ગતિશીલ રીતે જનરેટ કરી શકીએ છીએ.

# 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 પાઇપલાઇન ઇનપુટ અને કોઈપણ આદેશ વાક્ય દલીલો.

આ રેપર્સ સાથે તમે તમારા મનપસંદ Linux આદેશોને ઉપસર્ગ ઉમેર્યા વિના વધુ કુદરતી રીતે કૉલ કરી શકો છો wsl અને પાથ કેવી રીતે રૂપાંતરિત થાય છે તેની ચિંતા કર્યા વિના:

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

આદેશોનો મૂળભૂત સમૂહ અહીં બતાવવામાં આવ્યો છે, પરંતુ તમે કોઈપણ Linux આદેશ માટે તેને ફક્ત સૂચિમાં ઉમેરીને શેલ બનાવી શકો છો. જો તમે આ કોડ તમારામાં ઉમેરો છો પ્રોફાઇલ PowerShell, આ આદેશો તમારા માટે દરેક પાવરશેલ સત્રમાં ઉપલબ્ધ રહેશે, મૂળ આદેશોની જેમ જ!

મૂળભૂત સુયોજનો

લિનક્સમાં, લોગિન પ્રોફાઇલ્સમાં ઉપનામો અને/અથવા પર્યાવરણ ચલોને વ્યાખ્યાયિત કરવું સામાન્ય છે, વારંવાર ઉપયોગમાં લેવાતા આદેશો માટે ડિફૉલ્ટ પરિમાણો સેટ કરવા (ઉદાહરણ તરીકે, 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. નીચે આપેલ બતાવે છે કે ડિફોલ્ટ સેટિંગ્સને ગોઠવવા માટે તમારી પાવરશેલ પ્રોફાઇલમાં સૂચનાઓ કેવી રીતે ઉમેરવી. હવે અમે તે કરી શકીએ છીએ!

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

કારણ કે પરિમાણો પછી મોડેલ કરવામાં આવે છે $PSDefaultParameterValues, તમે કરી શકો છો તેમને અક્ષમ કરવું સરળ છે અસ્થાયી રૂપે કી ઇન્સ્ટોલ કરીને "Disabled" અર્થમાં $true. અલગ હેશ ટેબલનો વધારાનો ફાયદો એ અક્ષમ કરવાની ક્ષમતા છે $WslDefaultParameterValues થી અલગ $PSDefaultParameterValues.

દલીલ પૂર્ણ

પાવરશેલ તમને આદેશનો ઉપયોગ કરીને દલીલ ટ્રેલર્સની નોંધણી કરવાની મંજૂરી આપે છે Register-ArgumentCompleter. બાશ શક્તિશાળી છે પ્રોગ્રામેબલ ઓટો-કમ્પ્લીશન ટૂલ્સ. WSL તમને PowerShell માંથી 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]
    }
}

બેશના કેટલાક આંતરિક કાર્યોને સમજ્યા વિના કોડ થોડો ગાઢ છે, પરંતુ મૂળભૂત રીતે આપણે શું કરીએ છીએ તે છે:

• સૂચિ પસાર કરીને અમારા બધા ફંક્શન રેપર માટે દલીલ પૂર્ણ કરનારની નોંધણી કરવી $commands પરિમાણમાં -CommandName માટે Register-ArgumentCompleter.
• અમે દરેક કમાન્ડને શેલ ફંક્શન સાથે મેપ કરીએ છીએ જે bash સ્વતઃપૂર્ણતા માટે વાપરે છે (સ્વતઃપૂર્ણતા સ્પષ્ટીકરણો વ્યાખ્યાયિત કરવા માટે, bash ઉપયોગ કરે છે. $F, માટે સંક્ષેપ complete -F <FUNCTION>).
• PowerShell દલીલો રૂપાંતરિત કરી રહ્યા છીએ $wordToComplete, $commandAst и $cursorPosition સ્પષ્ટીકરણો અનુસાર bash ના સ્વતઃપૂર્ણ કાર્યો દ્વારા અપેક્ષિત ફોર્મેટમાં પ્રોગ્રામેબલ સ્વતઃ-પૂર્ણતા બેશ
• અમે ટ્રાન્સફર કરવા માટે કમાન્ડ લાઇન કંપોઝ કરીએ છીએ wsl.exe, જે ખાતરી કરે છે કે પર્યાવરણ યોગ્ય રીતે સેટ થયું છે, યોગ્ય સ્વતઃ-પૂર્ણ કાર્યને કૉલ કરે છે, અને પરિણામોને લાઇન-બાય-લાઇન ફેશનમાં આઉટપુટ કરે છે.
• પછી અમે કૉલ કરીએ છીએ wsl કમાન્ડ લાઇન સાથે, અમે લાઇન વિભાજક દ્વારા આઉટપુટને અલગ કરીએ છીએ અને દરેક માટે જનરેટ કરીએ છીએ CompletionResults, તેમને સૉર્ટ કરીને અને સ્પેસ અને કૌંસ જેવા અક્ષરોને બહાર કાઢો કે જે અન્યથા ખોટું અર્થઘટન કરવામાં આવશે.

પરિણામે, અમારા Linux કમાન્ડ શેલો bash તરીકે બરાબર એ જ સ્વતઃપૂર્ણતાનો ઉપયોગ કરશે! દાખ્લા તરીકે:

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

દરેક સ્વતઃપૂર્ણતા અગાઉની દલીલ માટે વિશિષ્ટ મૂલ્યો પૂરા પાડે છે, WSL માંથી જાણીતા હોસ્ટ્સ જેવા રૂપરેખાંકન ડેટા વાંચે છે!

<TAB> પરિમાણો દ્વારા ચક્ર કરશે. <Ctrl + пробел> બધા ઉપલબ્ધ વિકલ્પો બતાવશે.

ઉપરાંત, અમારી પાસે હવે બેશ ઓટોકમ્પલીશન હોવાથી, તમે પાવરશેલમાં સીધા જ Linux પાથને સ્વતઃપૂર્ણ કરી શકો છો!

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

એવા કિસ્સાઓમાં કે જ્યાં bash સ્વતઃપૂર્ણતા કોઈ પરિણામ લાવતું નથી, પાવરશેલ સિસ્ટમના ડિફોલ્ટ વિન્ડોઝ પાથ પર પાછા ફરે છે. આમ, વ્યવહારમાં, તમે તમારા વિવેકબુદ્ધિથી બંને માર્ગોનો એકસાથે ઉપયોગ કરી શકો છો.

નિષ્કર્ષ

PowerShell અને WSL નો ઉપયોગ કરીને, અમે Linux કમાન્ડને વિન્ડોઝમાં નેટીવ એપ્લિકેશન તરીકે એકીકૃત કરી શકીએ છીએ. Win32 બિલ્ડ્સ અથવા Linux ઉપયોગિતાઓ શોધવાની અથવા Linux શેલમાં જઈને તમારા વર્કફ્લોને અવરોધવાની જરૂર નથી. માત્ર WSL ઇન્સ્ટોલ કરો, રૂપરેખાંકિત કરો પાવરશેલ પ્રોફાઇલ и તમે આયાત કરવા માંગો છો તે આદેશોની સૂચિ બનાવો! Linux અને Windows કમાન્ડ પેરામીટર્સ અને ફાઇલ પાથ માટે સમૃદ્ધ સ્વતઃપૂર્ણતા એ કાર્યક્ષમતા છે જે આજે સ્થાનિક Windows આદેશોમાં પણ ઉપલબ્ધ નથી.

ઉપર વર્ણવેલ સંપૂર્ણ સ્રોત કોડ, તેમજ તેને તમારા વર્કફ્લોમાં સામેલ કરવા માટે વધારાની માર્ગદર્શિકા ઉપલબ્ધ છે અહીં.

તમને કયા Linux આદેશો સૌથી વધુ ઉપયોગી લાગે છે? વિન્ડોઝમાં કામ કરતી વખતે અન્ય કઈ સામાન્ય વસ્તુઓ ખૂટે છે? ટિપ્પણીઓમાં લખો અથવા GitHub પર!

સોર્સ: www.habr.com