Windows developer များထံမှ သာမာန်မေးခွန်းတစ်ခု- “ဘာကြောင့် မရှိသေးတာလဲ။ <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?။ အစွမ်းထက်တဲ့ ပွတ်ဆွဲမှုပဲဖြစ်ဖြစ်၊ less သို့မဟုတ် ရင်းနှီးသောကိရိယာများ grep သို့မဟုတ် sedWindows developer များသည် ၎င်းတို့၏နေ့စဉ်လုပ်ငန်းခွင်တွင် အဆိုပါ command များကို လွယ်ကူစွာ ဝင်ရောက်အသုံးပြုလိုကြသည်။

Linux အတွက် Windows Subsystem (WSL) ဒီကိစ္စမှာ ကြီးမားတဲ့ ခြေလှမ်းတစ်ခုကို လှမ်းနိုင်ခဲ့ပါတယ်။ ၎င်းသည် သင့်အား ၎င်းတို့အား proxy ပေးခြင်းဖြင့် Windows မှ Linux command များကို ခေါ်နိုင်သည်။ wsl.exe (ဥပမာ, wsl ls) ၎င်းသည် သိသာထင်ရှားသော တိုးတက်မှုတစ်ခုဖြစ်သော်လည်း၊ ဤရွေးချယ်မှုသည် အားနည်းချက်များစွာကို ကြုံတွေ့နေရသည်။

• နေရာအနှံ့ ထပ်လောင်း wsl ပျင်းစရာကောင်းပြီး သဘာဝမကျဘူး။
• backslashes များကို directory separators များထက် escape စာလုံးအဖြစ် အဓိပ္ပာယ်ပြန်ဆိုသောကြောင့် အငြင်းအခုံများရှိ Windows လမ်းကြောင်းများ အမြဲတမ်း အလုပ်မလုပ်ပါ။
• အကြောင်းပြချက်များရှိ Windows လမ်းကြောင်းများကို WSL တွင် သက်ဆိုင်ရာ mount point သို့ ဘာသာပြန်မထားပါ။
• နာမည်တူများနှင့် ပတ်ဝန်းကျင်ပြောင်းလွဲမှုများပါရှိသော WSL ပရိုဖိုင်များတွင် မူရင်းဆက်တင်များကို လေးစားမည်မဟုတ်ပါ။
• Linux လမ်းကြောင်း ပြီးစီးမှုကို ပံ့ပိုးမထားပါ။
• Command ပြီးဆုံးခြင်းကို မပံ့ပိုးပါ။
• အငြင်းအခုံပြီးစီးမှုကို မပံ့ပိုးပါ။

ရလဒ်အနေနှင့်၊ Linux command များကို Windows အောက်တွင် ဒုတိယတန်းစားနိုင်ငံသားများကဲ့သို့ သဘောထားပြီး- မူရင်း commands များထက် အသုံးပြုရ ပိုခက်ခဲသည်။ ၎င်းတို့၏ ရပိုင်ခွင့်များကို ညီမျှစေရန်၊ စာရင်းပြုစုထားသော ပြဿနာများကို ဖြေရှင်းရန် လိုအပ်ပါသည်။

PowerShell လုပ်ဆောင်ချက် ထုပ်ပိုးမှုများ

PowerShell function wrappers ဖြင့်၊ ကျွန်ုပ်တို့သည် command completion ကိုပေါင်းထည့်နိုင်ပြီး prefix များလိုအပ်မှုကို ဖယ်ရှားနိုင်ပါသည်။ wslWindows လမ်းကြောင်းများကို WSL လမ်းကြောင်းများအဖြစ် ဘာသာပြန်ဆိုခြင်း။ ခရုခွံများအတွက် အခြေခံလိုအပ်ချက်များ

• Linux command တစ်ခုစီအတွက် နာမည်တူ function wrapper တစ်ခုရှိရပါမည်။
• shell သည် အငြင်းအခုံများအဖြစ် ဖြတ်သွားသော Windows လမ်းကြောင်းများကို အသိအမှတ်ပြုပြီး ၎င်းတို့ကို WSL လမ်းကြောင်းများအဖြစ်သို့ ပြောင်းရပါမည်။
• ဘူးခွံလို့တော့ ခေါ်သင့်တယ်။ wsl သင့်လျော်သော Linux command ဖြင့် မည်သည့် pipeline input သို့မဆို command line argument များကို ဖြတ်သန်းပြီး function သို့ ပေးပို့သည်။

ဤပုံစံကို မည်သည့် command တွင်မဆို အသုံးချနိုင်သောကြောင့်၊ ကျွန်ုပ်တို့သည် ဤထုပ်ပိုးခြင်း၏ အဓိပ္ပါယ်ဖွင့်ဆိုချက်ကို ရှုတ်ချနိုင်ပြီး တင်သွင်းရန် ညွှန်ကြားချက်များစာရင်းမှ ၎င်းတို့ကို ဒိုင်နမစ်ဖြင့် ထုတ်လုပ်နိုင်သည်။

# 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 import commands များကို သတ်မှတ်သည်။ ထို့နောက် ကျွန်ုပ်တို့သည် command ကိုအသုံးပြု၍ ၎င်းတို့တစ်ခုစီအတွက် function wrapper တစ်ခုကို ဒိုင်းနမစ်ဖြင့် ထုတ်လုပ်သည်။ Invoke-Expression (လုပ်ဆောင်ချက်နှင့် ကွဲလွဲစေမည့် နံမည်များကို ဦးစွာ ဖယ်ရှားခြင်းဖြင့်)။

လုပ်ဆောင်ချက်သည် command line arguments များထက် ထပ်ကာထပ်ကာ ဖြစ်ပြီး၊ commands များကို အသုံးပြု၍ Windows လမ်းကြောင်းများကို ဆုံးဖြတ်ပေးသည်။ Split-Path и Test-Pathထို့နောက် ဤလမ်းကြောင်းများကို WSL လမ်းကြောင်းများအဖြစ်သို့ ပြောင်းသည်။ အကူအညီပေးသည့်လုပ်ဆောင်ချက်မှတစ်ဆင့် ကျွန်ုပ်တို့သည် လမ်းကြောင်းများကို လုပ်ဆောင်သည်။ Format-WslArgumentနောက်မှ သတ်မှတ်ပါမည်။ ၎င်းသည် တစ်နည်းတစ်ဖုံ အဓိပ္ပာယ်လွဲမှားခံရမည့် နေရာလွတ်များနှင့် ကွင်းစဥ်များကဲ့သို့သော အထူးဇာတ်ကောင်များမှ လွတ်ကင်းသည်။

နောက်ဆုံးအနေနဲ့ ကျွန်တော်တင်ပြတယ်။ wsl ပိုက်လိုင်းထည့်သွင်းခြင်းနှင့် မည်သည့် command line အကြောင်းပြချက်များ။

ဤထုပ်ပိုးမှုများဖြင့် သင်နှစ်သက်သော Linux အမိန့်များကို ရှေ့ဆက်မထည့်ဘဲ ပိုမိုသဘာဝကျသောနည်းလမ်းဖြင့် ခေါ်နိုင်သည်။ wsl လမ်းကြောင်းတွေ ဘယ်လိုပြောင်းသွားလဲ စိတ်ပူစရာမလိုဘဲ၊

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

အခြေခံ command အစုံကို ဤနေရာတွင် ပြထားသည်၊ သို့သော် ၎င်းကို စာရင်းထဲသို့ ထည့်ရုံဖြင့် မည်သည့် Linux command အတွက် shell တစ်ခုကို ဖန်တီးနိုင်သည်။ ဒီကုဒ်ကိုထည့်ရင် ပရိုဖိုင်းကို PowerShell၊ မူရင်း commands များကဲ့သို့ပင် PowerShell စက်ရှင်တိုင်းတွင် ဤအမိန့်များကို သင့်ထံ ရရှိနိုင်ပါသည်။

မူရင်းဆက်တင်များ

Linux တွင်၊ အကောင့်ဝင်ပရိုဖိုင်များတွင် နာမည်တူများနှင့်/သို့မဟုတ် ပတ်၀န်းကျင်ပြောင်းလွဲချက်များကို သတ်မှတ်ရန်၊ မကြာခဏအသုံးပြုသည့် command များအတွက် ပုံသေဘောင်များကို သတ်မှတ်ခြင်း (ဥပမာ၊ alias ls=ls -AFh သို့မဟုတ် export LESS=-i) အပြန်အလှန်တုံ့ပြန်မှုမရှိသော shell မှတဆင့် proxying ၏အားနည်းချက်များထဲမှတစ်ခု wsl.exe - ပရိုဖိုင်များကို မတင်ထားသောကြောင့် ဤရွေးချယ်မှုများကို ပုံသေအားဖြင့် မရရှိနိုင်ပါ (ဆိုလိုသည်မှာ၊ ls WSL နှင့် wsl ls အထက်ဖော်ပြပါ alias များနှင့် ကွဲပြားစွာ ပြုမူပါမည်။)

PowerShell ကထောက်ပံ့ပေးသည်။ $PSDefaultParameterValuesပုံသေဘောင်များကို သတ်မှတ်ခြင်းအတွက် စံယန္တရားတစ်ခုဖြစ်သော်လည်း cmdlets နှင့် အဆင့်မြင့်လုပ်ဆောင်ချက်များအတွက်သာ။ ဟုတ်ပါတယ်၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ အခွံများမှ အဆင့်မြင့်လုပ်ဆောင်ချက်များကို ပြုလုပ်နိုင်သော်လည်း ၎င်းသည် မလိုအပ်သော ရှုပ်ထွေးမှုများကို မိတ်ဆက်ပေးသည် (ဥပမာ၊ PowerShell သည် တစ်စိတ်တစ်ပိုင်း ကန့်သတ်ဘောင်အမည်များကို ဆက်စပ်ပေးသည် (ဥပမာ၊ -a နှင့်ဆက်စပ်နေသည်။ -ArgumentListတစ်စိတ်တစ်ပိုင်းအမည်များကို အငြင်းအခုံအဖြစ်ယူသော Linux command များနှင့် ကွဲလွဲမည့်)၊ မူရင်းတန်ဖိုးများကို သတ်မှတ်ခြင်းအတွက် syntax သည် အသင့်လျော်ဆုံးဖြစ်လိမ့်မည်မဟုတ်ပါ (မူလအငြင်းအခုံများသည် ကီးအတွင်းရှိ ပါရာမီတာ၏အမည်ကို လိုအပ်သည်၊ command name ကိုသာမက)၊ .

သို့သော်လည်း၊ ကျွန်ုပ်တို့၏ shells များကို အနည်းငယ် ပြုပြင်မွမ်းမံခြင်းဖြင့်၊ ကျွန်ုပ်တို့သည် အလားတူ မော်ဒယ်ကို အကောင်အထည် ဖော်နိုင်ပါသည်။ $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 command line သို့ကျွန်ုပ်တို့သည် parameters များကိုပေးပို့သည်။ wsl.exe. ပုံသေဆက်တင်များကို configure လုပ်ရန် သင်၏ PowerShell ပရိုဖိုင်တွင် ညွှန်ကြားချက်များ ထည့်သွင်းနည်းကို အောက်ပါတို့ပြသထားသည်။ ယခုကျွန်ုပ်တို့လုပ်နိုင်ပါပြီ။

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

ဘောင်များကို နမူနာယူထားသောကြောင့်ဖြစ်သည်။ $PSDefaultParameterValues, သင်လုပ်နိုင်သည် ၎င်းတို့ကို disable လုပ်ရန်လွယ်ကူသည်။ သော့ကို တပ်ဆင်ခြင်းဖြင့် ယာယီ "Disabled" အဓိပ္ပါယ်သို့ $true. သီးခြား hash table ၏နောက်ထပ်အကျိုးကျေးဇူးမှာ disable လုပ်နိုင်စွမ်းဖြစ်သည်။ $WslDefaultParameterValues မှ သီးခြား $PSDefaultParameterValues.

အငြင်းအခုံပြီးစီးခြင်း။

PowerShell သည် သင့်အား command ကို အသုံးပြု၍ အငြင်းအခုံတွဲများကို စာရင်းသွင်းရန် ခွင့်ပြုသည်။ Register-ArgumentCompleter. Bash သည် အစွမ်းထက်သည်။ ပရိုဂရမ်ထုတ်နိုင်သော အလိုအလျောက် ဖြည့်သွင်းနိုင်သော ကိရိယာများ. WSL သည် သင့်အား PowerShell မှ bash ခေါ်ဆိုရန် ခွင့်ပြုသည်။ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ PowerShell function wrappers အတွက် argument ပြီးစီးမှုများကို စာရင်းသွင်းနိုင်ပြီး ပြီးစီးမှုများကို ထုတ်ပေးရန်အတွက် 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 ၏အတွင်းပိုင်းလုပ်ဆောင်ချက်အချို့ကိုနားမလည်ဘဲ အနည်းငယ်သိပ်သည်းနေသော်လည်း အခြေခံအားဖြင့် ကျွန်ုပ်တို့လုပ်ဆောင်သောအရာမှာ ဤအရာဖြစ်သည်-

• စာရင်းတစ်ခုဖြတ်သန်းခြင်းဖြင့် ကျွန်ုပ်တို့၏လုပ်ဆောင်ချက် ထုပ်ပိုးမှုအားလုံးအတွက် အငြင်းပွားမှုတစ်ခုအား မှတ်ပုံတင်ခြင်း။ $commands parameter တွင် -CommandName အတွက် Register-ArgumentCompleter.
• ကျွန်ုပ်တို့သည် bash ၏ အလိုအလျောက်ဖြည့်ခြင်းအတွက် အသုံးပြုသည့် ကွန်မန်းတစ်ခုစီကို ချိန်ညှိပေးသည် (အလိုအလျောက်ဖြည့်သွင်းမှု သတ်မှတ်ချက်များကို သတ်မှတ်ရန်၊ bash ကို အသုံးပြုသည် $F, အတိုကောက် complete -F <FUNCTION>).
• PowerShell Arguments အဖြစ်ပြောင်းခြင်း။ $wordToComplete, $commandAst и $cursorPosition သတ်မှတ်ချက်များအရ bash ၏ အလိုအလျောက်ဖြည့်ခြင်းလုပ်ဆောင်ချက်များက မျှော်လင့်ထားသည့်ပုံစံသို့ ပရိုဂရမ်ထုတ်နိုင်သော အလိုအလျောက် ပြီးမြောက်မှု bash။
• ကျွန်ုပ်တို့ထံသို့ လွှဲပြောင်းရန် အမိန့်ပေးစာကြောင်းကို ရေးဖွဲ့ထားသည်။ wsl.exeပတ်ဝန်းကျင်ကို မှန်ကန်စွာ စနစ်ထည့်သွင်းကြောင်း သေချာစေသည့်၊ သင့်လျော်သော အလိုအလျောက် ဖြည့်သွင်းသည့် လုပ်ဆောင်ချက်ကို ခေါ်ဆိုကာ ရလဒ်များကို လိုင်းတစ်ခုပြီးတစ်ခု ဖက်ရှင်ဖြင့် ထုတ်ပေးပါသည်။
• နောက်တော့ ကျွန်တော်ဖုန်းဆက်တယ်။ wsl command line ဖြင့်၊ ကျွန်ုပ်တို့သည် output ကို line separators များဖြင့် ပိုင်းခြားပြီး တစ်ခုစီအတွက် generate လုပ်ပါသည်။ CompletionResults၎င်းတို့ကို စီခွဲခြင်းနှင့် လွဲမှားစွာ အဓိပ္ပာယ်ကောက်ယူမည့် နေရာလွတ်များနှင့် ကွင်းစဥ်များကဲ့သို့သော ဇာတ်ကောင်များ လွတ်မြောက်ခြင်း

ရလဒ်အနေဖြင့်၊ ကျွန်ုပ်တို့၏ Linux command shells များသည် bash ကဲ့သို့ အတိအကျတူညီသော အလိုအလျောက်ဖြည့်စွက်မှုကို အသုံးပြုမည်ဖြစ်သည်။ ဥပမာအားဖြင့်:

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

အလိုအလျောက်ဖြည့်စွက်မှုတစ်ခုစီသည် ယခင်အငြင်းအခုံအတွက် တိကျသောတန်ဖိုးများကို ပေးဆောင်သည်၊ WSL မှ သိထားသည့် hosts များကဲ့သို့သော ဖွဲ့စည်းမှုဒေတာကိုဖတ်ရှုခြင်း။

<TAB> parameters များမှတဆင့်လည်ပတ်လိမ့်မည်။ <Ctrl + пробел> ရနိုင်သောရွေးချယ်စရာအားလုံးကိုပြသလိမ့်မည်။

ထို့အပြင်၊ ကျွန်ုပ်တို့တွင် ယခု bash အလိုအလျောက်ဖြည့်သွင်းမှု ရှိသောကြောင့်၊ သင်သည် PowerShell တွင် Linux လမ်းကြောင်းများကို အလိုအလျောက်ဖြည့်နိုင်ပါသည်။

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

bash အလိုအလျောက်ဖြည့်စွက်ခြင်းသည် မည်သည့်ရလဒ်မျှ မထုတ်ပေးသည့်ကိစ္စများတွင်၊ PowerShell သည် စနစ်မူလ Windows လမ်းကြောင်းများသို့ ပြန်သွားသည်။ ထို့ကြောင့်၊ လက်တွေ့တွင်၊ သင်သည် သင်၏ဆုံးဖြတ်ချက်အတိုင်း လမ်းကြောင်းနှစ်ခုလုံးကို တစ်ပြိုင်နက် အသုံးပြုနိုင်သည်။

ကောက်ချက်

PowerShell နှင့် WSL ကို အသုံးပြု၍ ကျွန်ုပ်တို့သည် Linux အမိန့်များကို မူရင်းအက်ပ်များအဖြစ် Windows တွင် ပေါင်းစပ်နိုင်သည်။ Win32 တည်ဆောက်မှုများ သို့မဟုတ် Linux utilities များကို ရှာဖွေရန် သို့မဟုတ် Linux shell သို့သွားခြင်းဖြင့် သင့်လုပ်ငန်းအသွားအလာကို နှောက်ယှက်ရန် မလိုအပ်ပါ။ ရုံ WSL ကို install လုပ်ပါ။, configure PowerShell ပရိုဖိုင် и သင်တင်သွင်းလိုသော command များကိုစာရင်းပြုစုပါ။! Linux နှင့် Windows command parameters များနှင့် file paths များအတွက် ကြွယ်ဝသော အလိုအလျောက်ဖြည့်စွက်ခြင်းသည် ယနေ့ခေတ် မူရင်း Windows commands များတွင်ပင် မရရှိနိုင်သော လုပ်ဆောင်ချက်များ ဖြစ်ပါသည်။

အထက်တွင်ဖော်ပြထားသော ရင်းမြစ်ကုဒ်အပြည့်အစုံအပြင် ၎င်းကို သင်၏လုပ်ငန်းအသွားအလာတွင် ထည့်သွင်းခြင်းအတွက် နောက်ထပ်လမ်းညွှန်ချက်များကို ရရှိနိုင်ပါသည်။ ဒီမှာ.

ဘယ် Linux commands တွေက အသုံးအဝင်ဆုံးလဲ? Windows မှာ အလုပ်လုပ်တဲ့အခါ တခြားဘုံအရာတွေ ဘာတွေ လွဲနေလဲ။ comment မှာဖြစ်ဖြစ် ရေးပေးပါ။ GitHub တွင်!

source: www.habr.com