ຄໍາຖາມປົກກະຕິຈາກຜູ້ພັດທະນາ Windows: "ເປັນຫຍັງຍັງບໍ່ມີ <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. ບໍ່ວ່າຈະເປັນການປັດທີ່ມີອໍານາດ less ຫຼືເຄື່ອງມືທີ່ຄຸ້ນເຄີຍ grep ຫຼື sed, ນັກພັດທະນາ Windows ຕ້ອງການເຂົ້າຫາຄໍາສັ່ງເຫຼົ່ານີ້ໄດ້ງ່າຍໃນການເຮັດວຽກປະຈໍາວັນຂອງພວກເຂົາ.

ລະບົບຍ່ອຍ Windows ສໍາລັບ Linux (WSL) ໄດ້ມີບາດກ້າວອັນໃຫຍ່ຫຼວງໃນເລື່ອງນີ້. ມັນອະນຸຍາດໃຫ້ທ່ານສາມາດໂທຫາຄໍາສັ່ງ Linux ຈາກ Windows ໂດຍການເປັນຕົວແທນໃຫ້ເຂົາເຈົ້າຜ່ານ wsl.exe (ຕົວຢ່າງ: wsl ls). ເຖິງແມ່ນວ່ານີ້ແມ່ນການປັບປຸງທີ່ສໍາຄັນ, ທາງເລືອກນີ້ທົນທຸກຈາກຈໍານວນຂໍ້ເສຍ.

• ນອກ​ຈາກ​ນັ້ນ​ຢູ່​ທົ່ວ​ທຸກ​ແຫ່ງ​ wsl ເມື່ອຍແລະຜິດທໍາມະຊາດ.
• ເສັ້ນທາງ Windows ໃນການໂຕ້ຖຽງບໍ່ເຮັດວຽກຢູ່ສະ ເໝີ ເພາະວ່າ backslashes ຖືກຕີຄວາມ ໝາຍ ວ່າຕົວ ໜັງ ສືຫລົບ ໜີ ແທນທີ່ຈະຕົວແຍກໄດເລກະທໍລີ.
• ເສັ້ນທາງ Windows ໃນການໂຕ້ຖຽງບໍ່ໄດ້ແປເປັນຈຸດເຊື່ອມຕໍ່ທີ່ສອດຄ້ອງກັນໃນ WSL.
• ການຕັ້ງຄ່າເລີ່ມຕົ້ນບໍ່ຖືກເຄົາລົບໃນໂປຣໄຟລ໌ WSL ທີ່ມີນາມແຝງ ແລະຕົວແປສະພາບແວດລ້ອມ.
• ບໍ່ຮອງຮັບການສໍາເລັດເສັ້ນທາງ Linux.
• ບໍ່ຮອງຮັບການສໍາເລັດຄໍາສັ່ງ.
• ບໍ່ຮອງຮັບການສຳເລັດການໂຕ້ຖຽງ.

ດັ່ງນັ້ນ, ຄໍາສັ່ງ Linux ໄດ້ຖືກປະຕິບັດຄືກັບພົນລະເມືອງຊັ້ນທີສອງພາຍໃຕ້ Windows - ແລະມີຄວາມຫຍຸ້ງຍາກໃນການນໍາໃຊ້ຫຼາຍກ່ວາຄໍາສັ່ງພື້ນເມືອງ. ເພື່ອເຮັດໃຫ້ສິດຂອງເຂົາເຈົ້າເທົ່າທຽມກັນ, ມັນຈໍາເປັນຕ້ອງແກ້ໄຂບັນຫາທີ່ໄດ້ລະບຸໄວ້.

ຕົວຫໍ່ຟັງຊັນ PowerShell

ດ້ວຍ PowerShell function wrappers, ພວກເຮົາສາມາດເພີ່ມການສໍາເລັດຄໍາສັ່ງແລະລົບລ້າງຄວາມຕ້ອງການສໍາລັບຄໍານໍາຫນ້າ wsl, ການແປເສັ້ນທາງ Windows ເຂົ້າໄປໃນເສັ້ນທາງ WSL. ຂໍ້​ກໍາ​ນົດ​ພື້ນ​ຖານ​ສໍາ​ລັບ​ແກະ​:

• ສໍາລັບທຸກຄໍາສັ່ງ Linux ຕ້ອງມີຫນຶ່ງ wrapper ຟັງຊັນທີ່ມີຊື່ດຽວກັນ.
• Shell ຕ້ອງຮັບຮູ້ເສັ້ນທາງ Windows ທີ່ຜ່ານເປັນການໂຕ້ຖຽງແລະປ່ຽນເປັນເສັ້ນທາງ WSL.
• ແກະຄວນໂທຫາ wsl ດ້ວຍຄໍາສັ່ງ Linux ທີ່ເຫມາະສົມກັບການປ້ອນຂໍ້ມູນທໍ່ໃດນຶ່ງແລະຖ່າຍທອດການໂຕ້ຖຽງເສັ້ນຄໍາສັ່ງໃດໆທີ່ຜ່ານໄປຫາຫນ້າທີ່.

ເນື່ອງຈາກຮູບແບບນີ້ສາມາດຖືກນໍາໃຊ້ກັບຄໍາສັ່ງໃດໆ, ພວກເຮົາສາມາດ abstract ຄໍານິຍາມຂອງ wrappers ເຫຼົ່ານີ້ແລະສ້າງແບບເຄື່ອນໄຫວຈາກບັນຊີລາຍຊື່ຂອງຄໍາສັ່ງທີ່ຈະນໍາເຂົ້າ.

# 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 ກໍານົດຄໍາສັ່ງນໍາເຂົ້າ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາສ້າງ wrapper ຟັງຊັນແບບໄດນາມິກສໍາລັບແຕ່ລະຄົນຂອງພວກເຂົາໂດຍໃຊ້ຄໍາສັ່ງ Invoke-Expression (ໂດຍທໍາອິດເອົານາມແຝງທີ່ຈະຂັດກັບຟັງຊັນ).

ຟັງຊັນ iterates ໃນໄລຍະການໂຕ້ຖຽງເສັ້ນຄໍາສັ່ງ, ກໍານົດເສັ້ນທາງ Windows ໂດຍໃຊ້ຄໍາສັ່ງ Split-Path и Test-Pathແລະຫຼັງຈາກນັ້ນປ່ຽນເສັ້ນທາງເຫຼົ່ານີ້ໄປສູ່ເສັ້ນທາງ WSL. ພວກເຮົາແລ່ນເສັ້ນທາງຜ່ານຫນ້າທີ່ຜູ້ຊ່ວຍ Format-WslArgument, ທີ່ພວກເຮົາຈະກໍານົດຕໍ່ມາ. ມັນໜີອອກຈາກຕົວອັກສອນພິເສດເຊັ່ນ: ຍະຫວ່າງ ແລະວົງເລັບທີ່ອາດຈະຖືກຕີຄວາມໝາຍຜິດ.

ສຸດທ້າຍ, ພວກເຮົາຖ່າຍທອດ wsl ການ​ປ້ອນ​ຂໍ້​ມູນ pipeline ແລະ​ການ​ໂຕ້​ຖຽງ​ບັນ​ຊີ​ຄໍາ​ສັ່ງ​ໃດໆ​.

ດ້ວຍ wrappers ເຫຼົ່ານີ້ທ່ານສາມາດໂທຫາຄໍາສັ່ງ Linux ທີ່ທ່ານມັກໃນແບບທໍາມະຊາດຫຼາຍໂດຍບໍ່ມີການເພີ່ມຄໍານໍາຫນ້າ wsl ແລະ​ໂດຍ​ບໍ່​ມີ​ການ​ກັງ​ວົນ​ກ່ຽວ​ກັບ​ວິ​ທີ​ການ​ປ່ຽນ​ແປງ​ເສັ້ນ​ທາງ:

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

ຊຸດຄໍາສັ່ງພື້ນຖານແມ່ນສະແດງຢູ່ນີ້, ແຕ່ທ່ານສາມາດສ້າງ shell ສໍາລັບຄໍາສັ່ງ Linux ໃດກໍ່ຕາມໂດຍການເພີ່ມມັນໃສ່ບັນຊີລາຍຊື່. ຖ້າທ່ານເພີ່ມລະຫັດນີ້ໃສ່ຂອງທ່ານ ຂໍ້ມູນ PowerShell, ຄໍາສັ່ງເຫຼົ່ານີ້ຈະມີໃຫ້ທ່ານໃນທຸກໆເຊດຊັນ PowerShell, ຄືກັນກັບຄໍາສັ່ງພື້ນເມືອງ!

ການຕັ້ງຄ່າເລີ່ມຕົ້ນ

ໃນ Linux, ມັນເປັນເລື່ອງທໍາມະດາທີ່ຈະກໍານົດນາມແຝງແລະ / ຫຼືຕົວແປສະພາບແວດລ້ອມໃນໂປຣໄຟລ໌ເຂົ້າສູ່ລະບົບ, ກໍານົດຄ່າເລີ່ມຕົ້ນສໍາລັບຄໍາສັ່ງທີ່ໃຊ້ເລື້ອຍໆ (ຕົວຢ່າງເຊັ່ນ, alias ls=ls -AFh ຫຼື export LESS=-i). ຫນຶ່ງໃນຂໍ້ເສຍຂອງ proxying ຜ່ານ shell ທີ່ບໍ່ມີການໂຕ້ຕອບ wsl.exe - ທີ່ໂປໄຟບໍ່ໄດ້ຖືກໂຫລດ, ດັ່ງນັ້ນທາງເລືອກເຫຼົ່ານີ້ບໍ່ສາມາດໃຊ້ໄດ້ໂດຍຄ່າເລີ່ມຕົ້ນ (i.e. ls ໃນ WSL ແລະ wsl ls ຈະປະຕິບັດຕົວແຕກຕ່າງກັນກັບນາມແຝງທີ່ໄດ້ກໍານົດໄວ້ຂ້າງເທິງ).

PowerShell ໃຫ້ $PSDefaultParameterValues, ກົນໄກມາດຕະຖານສໍາລັບການກໍານົດຄ່າເລີ່ມຕົ້ນ, ແຕ່ພຽງແຕ່ສໍາລັບ cmdlets ແລະຫນ້າທີ່ກ້າວຫນ້າ. ແນ່ນອນ, ພວກເຮົາສາມາດເຮັດຫນ້າທີ່ຂັ້ນສູງອອກຈາກແກະຂອງພວກເຮົາ, ແຕ່ນີ້ແນະນໍາອາການແຊກຊ້ອນທີ່ບໍ່ຈໍາເປັນ (ຕົວຢ່າງ, PowerShell ກ່ຽວຂ້ອງກັບຊື່ພາລາມິເຕີບາງສ່ວນ (ຕົວຢ່າງ: -a ກ່ຽວຂ້ອງກັບ -ArgumentList), ເຊິ່ງຈະຂັດແຍ້ງກັບຄໍາສັ່ງ Linux ທີ່ເອົາຊື່ບາງສ່ວນເປັນ arguments), ແລະ syntax ສໍາລັບກໍານົດຄ່າເລີ່ມຕົ້ນຈະບໍ່ເຫມາະສົມທີ່ສຸດ (ການໂຕ້ຖຽງເລີ່ມຕົ້ນຕ້ອງການຊື່ຂອງພາລາມິເຕີໃນຄີ, ບໍ່ພຽງແຕ່ຊື່ຄໍາສັ່ງ) .

ຢ່າງໃດກໍຕາມ, ດ້ວຍການດັດແປງເລັກນ້ອຍຂອງແກະຂອງພວກເຮົາ, ພວກເຮົາສາມາດປະຕິບັດຕົວແບບທີ່ຄ້າຍຄືກັນກັບ $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"

ນັບຕັ້ງແຕ່ຕົວກໍານົດການແມ່ນ modeled ຫຼັງຈາກ $PSDefaultParameterValues, ເຈົ້າ​ສາ​ມາດ ມັນງ່າຍທີ່ຈະປິດການໃຊ້ງານພວກມັນ ຊົ່ວຄາວໂດຍການຕິດຕັ້ງຄີ "Disabled" ເຂົ້າໄປໃນຄວາມຫມາຍ $true. ຜົນປະໂຫຍດເພີ່ມເຕີມຂອງຕາຕະລາງ hash ແຍກຕ່າງຫາກແມ່ນຄວາມສາມາດໃນການປິດການໃຊ້ງານ $WslDefaultParameterValues ແຍກຕ່າງຫາກຈາກ $PSDefaultParameterValues.

ສຳເລັດການໂຕ້ຖຽງ

PowerShell ອະນຸຍາດໃຫ້ທ່ານລົງທະບຽນ trailer argument ໂດຍໃຊ້ຄໍາສັ່ງ Register-ArgumentCompleter. Bash ມີອໍານາດ ເຄື່ອງ​ມື​ສໍາ​ເລັດ​ອັດ​ຕະ​ໂນ​ມັດ​ທີ່​ຕັ້ງ​ໂຄງ​ການ​. 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]
    }
}

ລະຫັດແມ່ນມີຄວາມຫນາແຫນ້ນເລັກນ້ອຍໂດຍບໍ່ໄດ້ເຂົ້າໃຈບາງຫນ້າທີ່ພາຍໃນຂອງ bash, ແຕ່ໂດຍພື້ນຖານແລ້ວສິ່ງທີ່ພວກເຮົາເຮັດແມ່ນນີ້:

• ການລົງທະບຽນການໂຕ້ຖຽງທີ່ສົມບູນຂຶ້ນສໍາລັບ wrappers ຟັງຊັນຂອງພວກເຮົາທັງຫມົດໂດຍການຜ່ານບັນຊີລາຍຊື່ $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>

ແຕ່ລະ autocompletion ສະຫນອງຄ່າສະເພາະກັບ argument ທີ່ຜ່ານມາ, ອ່ານຂໍ້ມູນການຕັ້ງຄ່າເຊັ່ນ hosts ທີ່ຮູ້ຈັກຈາກ WSL!

<TAB> ຈະວົງຈອນຜ່ານຕົວກໍານົດການ. <Ctrl + пробел> ຈະສະແດງທາງເລືອກທີ່ມີທັງຫມົດ.

ນອກຈາກນັ້ນ, ເນື່ອງຈາກຕອນນີ້ພວກເຮົາມີການຕື່ມຂໍ້ມູນອັດຕະໂນມັດ bash, ທ່ານສາມາດຕື່ມຂໍ້ມູນໃສ່ເສັ້ນທາງ Linux ໂດຍກົງໃນ PowerShell!

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

ໃນ​ກໍ​ລະ​ນີ​ທີ່​ການ​ຕື່ມ​ຂໍ້​ມູນ​ອັດ​ຕະ​ໂນ​ມັດ bash ບໍ່​ໄດ້​ຮັບ​ຜົນ​ໄດ້​ຮັບ​ໃດໆ​, PowerShell ກັບ​ຄືນ​ໄປ​ບ່ອນ​ເສັ້ນ​ທາງ​ເລີ່ມ​ຕົ້ນ Windows ຂອງ​ລະ​ບົບ​. ດັ່ງນັ້ນ, ໃນການປະຕິບັດ, ທ່ານສາມາດນໍາໃຊ້ທັງສອງເສັ້ນທາງໃນເວລາດຽວກັນຕາມການຕັດສິນໃຈຂອງທ່ານ.

ສະຫລຸບ

ການນໍາໃຊ້ PowerShell ແລະ WSL, ພວກເຮົາສາມາດປະສົມປະສານຄໍາສັ່ງ Linux ເຂົ້າໄປໃນ Windows ເປັນຄໍາຮ້ອງສະຫມັກພື້ນເມືອງ. ບໍ່ຈໍາເປັນຕ້ອງຊອກຫາ Win32 builds ຫຼື Linux utilities ຫຼືຂັດຂວາງການເຮັດວຽກຂອງທ່ານໂດຍການໄປທີ່ Linux shell. ພຽງແຕ່ ຕິດຕັ້ງ WSL, ຕັ້ງຄ່າ ໂປຣໄຟລ໌ PowerShell и ບອກຄໍາສັ່ງທີ່ທ່ານຕ້ອງການນໍາເຂົ້າ! ການຕື່ມຂໍ້ມູນອັດຕະໂນມັດທີ່ອຸດົມສົມບູນສໍາລັບພາລາມິເຕີຄໍາສັ່ງ Linux ແລະ Windows ແລະເສັ້ນທາງໄຟລ໌ແມ່ນຫນ້າທີ່ຍັງບໍ່ມີຢູ່ໃນຄໍາສັ່ງ Windows ພື້ນເມືອງໃນມື້ນີ້.

ລະຫັດແຫຼ່ງເຕັມທີ່ອະທິບາຍຂ້າງເທິງ, ເຊັ່ນດຽວກັນກັບຄໍາແນະນໍາເພີ່ມເຕີມສໍາລັບການລວມເອົາມັນເຂົ້າໄປໃນຂະບວນການເຮັດວຽກຂອງທ່ານ, ແມ່ນມີຢູ່ ທີ່ນີ້.

ຄໍາສັ່ງ Linux ໃດທີ່ທ່ານເຫັນວ່າເປັນປະໂຫຍດທີ່ສຸດ? ສິ່ງທົ່ວໄປອື່ນໆທີ່ຂາດຫາຍໄປໃນເວລາທີ່ເຮັດວຽກຢູ່ໃນ Windows? ຂຽນໃນຄໍາເຫັນຫຼື ໃນ GitHub!

ແຫຼ່ງຂໍ້ມູນ: www.habr.com