വിൻഡോസ് ഡെവലപ്പർമാരിൽ നിന്നുള്ള ഒരു സാധാരണ ചോദ്യം: “എന്തുകൊണ്ട് ഇപ്പോഴും ഇല്ല <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. അത് ശക്തമായ സ്വൈപ്പ് ആണെങ്കിലും less അല്ലെങ്കിൽ പരിചിതമായ ഉപകരണങ്ങൾ grep അഥവാ sed, Windows ഡവലപ്പർമാർ അവരുടെ ദൈനംദിന ജോലിയിൽ ഈ കമാൻഡുകൾ എളുപ്പത്തിൽ ആക്സസ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നു.

ലിനക്സിനുള്ള വിൻഡോസ് സബ്സിസ്റ്റം (WSL) ഇക്കാര്യത്തിൽ ഒരു വലിയ മുന്നേറ്റം നടത്തിയിട്ടുണ്ട്. വിൻഡോസിൽ നിന്ന് ലിനക്സ് കമാൻഡുകൾ പ്രോക്സി ചെയ്തുകൊണ്ട് വിളിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു wsl.exe (ഉദാ. wsl ls). ഇത് കാര്യമായ പുരോഗതിയാണെങ്കിലും, ഈ ഓപ്ഷൻ നിരവധി ദോഷങ്ങളാൽ കഷ്ടപ്പെടുന്നു.

• സർവ്വവ്യാപിയായ കൂട്ടിച്ചേർക്കൽ wsl മടുപ്പിക്കുന്നതും പ്രകൃതിവിരുദ്ധവുമാണ്.
• ഡയറക്‌ടറി സെപ്പറേറ്ററുകളേക്കാൾ ബാക്ക്‌സ്ലാഷുകൾ എസ്‌കേപ്പ് പ്രതീകങ്ങളായി വ്യാഖ്യാനിക്കപ്പെടുന്നതിനാൽ ആർഗ്യുമെന്റുകളിലെ വിൻഡോസ് പാത്തുകൾ എല്ലായ്പ്പോഴും പ്രവർത്തിക്കില്ല.
• ആർഗ്യുമെന്റുകളിലെ വിൻഡോസ് പാഥുകൾ WSL-ലെ മൌണ്ട് പോയിന്റിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നില്ല.
• അപരനാമങ്ങളും എൻവയോൺമെന്റ് വേരിയബിളുകളും ഉള്ള WSL പ്രൊഫൈലുകളിൽ സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ മാനിക്കപ്പെടുന്നില്ല.
• Linux പാത്ത് പൂർത്തീകരണം പിന്തുണയ്ക്കുന്നില്ല.
• കമാൻഡ് പൂർത്തിയാക്കൽ പിന്തുണയ്ക്കുന്നില്ല.
• വാദം പൂർത്തീകരണം പിന്തുണയ്ക്കുന്നില്ല.

തൽഫലമായി, ലിനക്സ് കമാൻഡുകൾ വിൻഡോസിന് കീഴിൽ രണ്ടാം തരം പൗരന്മാരെപ്പോലെയാണ് പരിഗണിക്കുന്നത് - കൂടാതെ നേറ്റീവ് കമാൻഡുകളേക്കാൾ ഉപയോഗിക്കാൻ ബുദ്ധിമുട്ടാണ്. അവരുടെ അവകാശങ്ങൾ തുല്യമാക്കുന്നതിന്, ലിസ്റ്റുചെയ്ത പ്രശ്നങ്ങൾ പരിഹരിക്കേണ്ടത് ആവശ്യമാണ്.

പവർഷെൽ ഫംഗ്ഷൻ റാപ്പറുകൾ

PowerShell ഫംഗ്‌ഷൻ റാപ്പറുകൾ ഉപയോഗിച്ച്, നമുക്ക് കമാൻഡ് പൂർത്തീകരണം ചേർക്കാനും പ്രിഫിക്‌സുകളുടെ ആവശ്യകത ഇല്ലാതാക്കാനും കഴിയും. wsl, വിൻഡോസ് പാത്തുകൾ WSL പാത്തുകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. ഷെല്ലുകൾക്കുള്ള അടിസ്ഥാന ആവശ്യകതകൾ:

• ഓരോ Linux കമാൻഡിനും ഒരേ പേരിൽ ഒരു ഫംഗ്ഷൻ റാപ്പർ ഉണ്ടായിരിക്കണം.
• ഷെൽ ആർഗ്യുമെന്റുകളായി പാസ്സാക്കിയ വിൻഡോസ് പാത്തുകൾ തിരിച്ചറിയുകയും അവയെ 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

കമാൻഡുകളുടെ അടിസ്ഥാന സെറ്റ് ഇവിടെ കാണിച്ചിരിക്കുന്നു, എന്നാൽ ലിസ്‌റ്റിൽ ചേർത്തുകൊണ്ട് ഏത് ലിനക്‌സ് കമാൻഡിനും ഷെൽ സൃഷ്‌ടിക്കാനാകും. നിങ്ങളിലേക്ക് ഈ കോഡ് ചേർക്കുകയാണെങ്കിൽ പ്രൊഫൈൽ പവർഷെൽ, നേറ്റീവ് കമാൻഡുകൾ പോലെ ഈ കമാൻഡുകൾ എല്ലാ PowerShell സെഷനിലും നിങ്ങൾക്ക് ലഭ്യമാകും!

സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ

ലിനക്സിൽ, ലോഗിൻ പ്രൊഫൈലുകളിൽ അപരനാമങ്ങളും കൂടാതെ/അല്ലെങ്കിൽ എൻവയോൺമെന്റ് വേരിയബിളുകളും നിർവചിക്കുന്നത് സാധാരണമാണ്, പതിവായി ഉപയോഗിക്കുന്ന കമാൻഡുകൾക്കായി സ്ഥിരസ്ഥിതി പാരാമീറ്ററുകൾ സജ്ജമാക്കുന്നു (ഉദാഹരണത്തിന്, alias ls=ls -AFh അഥവാ export LESS=-i). ഒരു നോൺ-ഇന്ററാക്ടീവ് ഷെല്ലിലൂടെ പ്രോക്‌സി ചെയ്യുന്നതിന്റെ ഒരു പോരായ്മ wsl.exe - പ്രൊഫൈലുകൾ ലോഡ് ചെയ്തിട്ടില്ല, അതിനാൽ ഈ ഓപ്ഷനുകൾ ഡിഫോൾട്ടായി ലഭ്യമല്ല (അതായത്. ls WSL ൽ ഒപ്പം wsl ls മുകളിൽ നിർവചിച്ചിരിക്കുന്ന അപരനാമത്തിൽ വ്യത്യസ്തമായി പെരുമാറും).

PowerShell നൽകുന്നു $PSDefaultParameterValues, ഡിഫോൾട്ട് പാരാമീറ്ററുകൾ നിർവചിക്കുന്നതിനുള്ള ഒരു സ്റ്റാൻഡേർഡ് മെക്കാനിസം, എന്നാൽ cmdlets-നും വിപുലമായ ഫംഗ്ഷനുകൾക്കും മാത്രം. തീർച്ചയായും, നമുക്ക് ഞങ്ങളുടെ ഷെല്ലുകളിൽ നിന്ന് വിപുലമായ ഫംഗ്‌ഷനുകൾ നിർമ്മിക്കാൻ കഴിയും, എന്നാൽ ഇത് അനാവശ്യമായ സങ്കീർണതകൾ അവതരിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, PowerShell ഭാഗിക പാരാമീറ്റർ പേരുകൾ പരസ്പരം ബന്ധപ്പെടുത്തുന്നു (ഉദാഹരണത്തിന്, -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.

വാദം പൂർത്തീകരണം

കമാൻഡ് ഉപയോഗിച്ച് ആർഗ്യുമെന്റ് ട്രെയിലറുകൾ രജിസ്റ്റർ ചെയ്യാൻ PowerShell നിങ്ങളെ അനുവദിക്കുന്നു Register-ArgumentCompleter. ബാഷിന് ശക്തിയുണ്ട് പ്രോഗ്രാം ചെയ്യാവുന്ന യാന്ത്രിക പൂർത്തീകരണ ഉപകരണങ്ങൾ. PowerShell-ൽ നിന്ന് ബാഷ് വിളിക്കാൻ 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>).
• PowerShell ആർഗ്യുമെന്റുകൾ പരിവർത്തനം ചെയ്യുന്നു $wordToComplete, $commandAst и $cursorPosition സ്പെസിഫിക്കേഷനുകൾക്കനുസരിച്ച് ബാഷിന്റെ സ്വയം പൂർത്തീകരണ പ്രവർത്തനങ്ങൾ പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റിലേക്ക് പ്രോഗ്രാം ചെയ്യാവുന്ന യാന്ത്രിക പൂർത്തീകരണം ബാഷ്.
• കൈമാറാൻ ഞങ്ങൾ ഒരു കമാൻഡ് ലൈൻ രചിക്കുന്നു wsl.exe, പരിസ്ഥിതി ശരിയായി സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുകയും ഉചിതമായ ഓട്ടോ-കംപ്ലീഷൻ ഫംഗ്‌ഷനെ വിളിക്കുകയും ഫലങ്ങൾ ലൈൻ-ബൈ-ലൈൻ ഫാഷനിൽ ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു.
• അപ്പോൾ ഞങ്ങൾ വിളിക്കുന്നു wsl കമാൻഡ് ലൈൻ ഉപയോഗിച്ച്, ലൈൻ സെപ്പറേറ്ററുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ ഔട്ട്പുട്ട് വേർതിരിച്ച് ഓരോന്നിനും സൃഷ്ടിക്കുന്നു CompletionResults, അവയെ അടുക്കുകയും സ്‌പെയ്‌സുകളും പരാൻതീസിസും പോലുള്ള പ്രതീകങ്ങളിൽ നിന്ന് രക്ഷപ്പെടുകയും ചെയ്യുന്നു, അത് തെറ്റായി വ്യാഖ്യാനിക്കപ്പെടും.

തൽഫലമായി, ഞങ്ങളുടെ Linux കമാൻഡ് ഷെല്ലുകൾ ബാഷിന്റെ അതേ സ്വയം പൂർത്തീകരണം ഉപയോഗിക്കും! ഉദാഹരണത്തിന്:

• 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 ഇൻസ്റ്റാൾ ചെയ്യുക, കോൺഫിഗർ ചെയ്യുക പവർഷെൽ പ്രൊഫൈൽ и നിങ്ങൾ ഇറക്കുമതി ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കമാൻഡുകൾ ലിസ്റ്റ് ചെയ്യുക! ലിനക്സ്, വിൻഡോസ് കമാൻഡ് പാരാമീറ്ററുകൾക്കും ഫയൽ പാഥുകൾക്കുമുള്ള റിച്ച് സ്വയമേവ പൂർത്തീകരണം ഇന്ന് നേറ്റീവ് വിൻഡോസ് കമാൻഡുകളിൽ പോലും ലഭ്യമല്ലാത്ത പ്രവർത്തനമാണ്.

മുകളിൽ വിവരിച്ച മുഴുവൻ സോഴ്‌സ് കോഡും അത് നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ ഉൾപ്പെടുത്തുന്നതിനുള്ള അധിക മാർഗ്ഗനിർദ്ദേശങ്ങളും ലഭ്യമാണ് ഇവിടെ.

ഏത് Linux കമാൻഡുകളാണ് നിങ്ങൾക്ക് ഏറ്റവും ഉപയോഗപ്രദമെന്ന് തോന്നുന്നത്? വിൻഡോസിൽ പ്രവർത്തിക്കുമ്പോൾ മറ്റ് എന്ത് സാധാരണ കാര്യങ്ങൾ കാണുന്നില്ല? അഭിപ്രായങ്ങളിൽ എഴുതുക അല്ലെങ്കിൽ GitHub-ൽ!

അവലംബം: www.habr.com