ტიპიური შეკითხვა Windows-ის დეველოპერებისგან: „რატომ ჯერ კიდევ არ არის <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. იქნება ეს ძლიერი დარტყმა less ან ნაცნობი იარაღები grep ან sedWindows-ის დეველოპერებს სურთ ამ ბრძანებებზე მარტივი წვდომა ყოველდღიურ მუშაობაში.

Windows ქვესისტემა Linux-ისთვის (WSL) ამ კუთხით დიდი წინგადადგმული ნაბიჯი გადადგა. ის საშუალებას გაძლევთ გამოიძახოთ Linux ბრძანებები Windows-დან მათი პროქსის მეშვეობით wsl.exe (მაგალითად, wsl ls). მიუხედავად იმისა, რომ ეს არის მნიშვნელოვანი გაუმჯობესება, ამ ვარიანტს აქვს მთელი რიგი უარყოფითი მხარეები.

• საყოველთაო დამატება wsl დამღლელი და არაბუნებრივი.
• Windows-ის ბილიკები არგუმენტებში ყოველთვის არ მუშაობს, რადგან უკანა ხაზები ინტერპრეტირებულია, როგორც გაქცევის სიმბოლოები და არა დირექტორიას გამყოფები.
• Windows-ის ბილიკები არგუმენტებში არ ითარგმნება WSL-ის შესაბამის სამონტაჟო წერტილში.
• ნაგულისხმევი პარამეტრები არ არის დაცული WSL პროფილებში მეტსახელებითა და გარემოს ცვლადებით.
• Linux ბილიკის დასრულება არ არის მხარდაჭერილი.
• ბრძანების დასრულება არ არის მხარდაჭერილი.
• არგუმენტის დასრულება მხარდაჭერილი არ არის.

შედეგად, Linux-ის ბრძანებები განიხილება, როგორც მეორე კლასის მოქალაქეები Windows-ში - და უფრო რთული გამოსაყენებელია, ვიდრე მშობლიური ბრძანებები. მათი უფლებების გასათანაბრებლად აუცილებელია ჩამოთვლილი პრობლემების გადაჭრა.

PowerShell ფუნქციის შეფუთვები

PowerShell ფუნქციის შეფუთვით, ჩვენ შეგვიძლია დავამატოთ ბრძანების დასრულება და აღმოვფხვრათ პრეფიქსების საჭიროება wslWindows ბილიკების თარგმნა WSL ბილიკებად. ჭურვის ძირითადი მოთხოვნები:

• Linux-ის ყველა ბრძანებისთვის უნდა იყოს ერთი ფუნქციის შეფუთვა იგივე სახელით.
• Shell-მა უნდა აღიაროს არგუმენტებად გადაცემული 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 (პირველ რიგში ნებისმიერი მეტსახელის წაშლით, რომელიც ეწინააღმდეგება ფუნქციას).

ფუნქცია იმეორებს ბრძანების ხაზის არგუმენტებს, განსაზღვრავს Windows ბილიკებს ბრძანებების გამოყენებით 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, ეს ბრძანებები ხელმისაწვდომი იქნება თქვენთვის PowerShell-ის ყველა სესიაზე, ისევე როგორც მშობლიური ბრძანებები!

ნაგულისხმევი პარამეტრები

Linux-ში ხშირია ალიასების და/ან გარემოს ცვლადების განსაზღვრა შესვლის პროფილებში, ხშირად გამოყენებული ბრძანებების ნაგულისხმევი პარამეტრების დაყენება (მაგალითად, alias ls=ls -AFh ან export LESS=-i). არაინტერაქტიული გარსის მეშვეობით პროქსიინგის ერთ-ერთი მინუსი wsl.exe - რომ პროფილები არ არის ჩატვირთული, ამიტომ ეს პარამეტრები არ არის ხელმისაწვდომი ნაგულისხმევად (ე.ი. ls WSL-ში და wsl ls განსხვავებულად მოიქცევა ზემოთ განსაზღვრული მეტსახელით).

PowerShell უზრუნველყოფს $PSDefaultParameterValuesსტანდარტული მექანიზმი ნაგულისხმევი პარამეტრების განსაზღვრისთვის, მაგრამ მხოლოდ cmdlet-ებისთვის და გაფართოებული ფუნქციებისთვის. რა თქმა უნდა, ჩვენ შეგვიძლია შევქმნათ მოწინავე ფუნქციები ჩვენი ჭურვიდან, მაგრამ ეს იწვევს არასაჭირო გართულებებს (მაგალითად, PowerShell აკავშირებს პარამეტრების ნაწილობრივ სახელებს (მაგალითად, -a უკავშირდება -ArgumentList), რომელიც ეწინააღმდეგება Linux-ის ბრძანებებს, რომლებიც არგუმენტებად იღებენ ნაწილობრივ სახელებს) და ნაგულისხმევი არგუმენტების განსაზღვრის სინტაქსი არ იქნება ყველაზე შესაფერისი (ნაგულისხმევი არგუმენტების განსაზღვრა მოითხოვს პარამეტრის სახელს გასაღებში და არა მხოლოდ ბრძანების სახელს).

თუმცა, ჩვენი ჭურვების მცირე მოდიფიკაციით, ჩვენ შეგვიძლია განვახორციელოთ მსგავსი მოდელი $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. ბაშს აქვს ძლიერი პროგრამირებადი ავტომატური დასრულების ინსტრუმენტები. WSL გაძლევთ საშუალებას გამოძახოთ bash PowerShell-იდან. თუ ჩვენ შეგვიძლია დავარეგისტრიროთ არგუმენტების დასრულება ჩვენი 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]
    }
}

კოდი ცოტა მკვრივია ბაშის ზოგიერთი შინაგანი ფუნქციის გააზრების გარეშე, მაგრამ ძირითადად რასაც ვაკეთებთ არის ეს:

• არგუმენტის შემავსებლის რეგისტრაცია ყველა ჩვენი ფუნქციის შეფუთვებისთვის სიის გადაცემით $commands პარამეტრში -CommandName ამისთვის Register-ArgumentCompleter.
• ჩვენ ვაფიქსირებთ თითოეულ ბრძანებას shell ფუნქციაზე, რომელსაც 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 + пробел> აჩვენებს ყველა შესაძლო ვარიანტს.

გარდა ამისა, რადგან ჩვენ ახლა გვაქვს bash ავტომატური დასრულება, შეგიძლიათ ავტომატურად შეავსოთ Linux ბილიკები პირდაპირ PowerShell-ში!

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

იმ შემთხვევებში, როდესაც bash ავტომატური დასრულება არ იძლევა რაიმე შედეგს, PowerShell უბრუნდება სისტემის ნაგულისხმევ Windows ბილიკებს. ამრიგად, პრაქტიკაში, თქვენ შეგიძლიათ ერთდროულად გამოიყენოთ ორივე გზა თქვენი შეხედულებისამებრ.

დასკვნა

PowerShell-ისა და WSL-ის გამოყენებით, ჩვენ შეგვიძლია Linux-ის ბრძანებების ინტეგრირება Windows-ში, როგორც მშობლიურ აპლიკაციებში. არ არის საჭირო Win32 build-ების ან Linux-ის უტილიტების ძიება ან თქვენი სამუშაო პროცესის შეწყვეტა Linux-ის გარსზე გადასვლით. Უბრალოდ დააინსტალირეთ WSL, კონფიგურაცია PowerShell პროფილი и ჩამოთვალეთ ბრძანებები, რომელთა იმპორტი გსურთ! მდიდარი ავტომატური დასრულება Linux-ისა და Windows-ის ბრძანების პარამეტრებისა და ფაილის ბილიკებისთვის არის ფუნქციონალობა, რომელიც დღეს არ არის ხელმისაწვდომი Windows-ის მშობლიურ ბრძანებებშიც კი.

ზემოთ აღწერილი სრული წყაროს კოდი, ისევე როგორც დამატებითი ინსტრუქციები თქვენს სამუშაო პროცესში მისი ჩართვისთვის, ხელმისაწვდომია აქ.

Linux-ის რომელი ბრძანებები მიგაჩნიათ ყველაზე სასარგებლო? რა სხვა საერთო რამ აკლია Windows-ში მუშაობისას? დაწერეთ კომენტარებში ან GitHub-ზე!

წყარო: www.habr.com