ਵਿੰਡੋਜ਼ ਡਿਵੈਲਪਰਾਂ ਦਾ ਇੱਕ ਆਮ ਸਵਾਲ: “ਅਜੇ ਵੀ ਕੋਈ ਕਿਉਂ ਨਹੀਂ ਹੈ <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. ਭਾਵੇਂ ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਵਾਈਪ ਹੋਵੇ less ਜਾਂ ਜਾਣੇ-ਪਛਾਣੇ ਸਾਧਨ grep ਜ sed, ਵਿੰਡੋਜ਼ ਡਿਵੈਲਪਰ ਆਪਣੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਵਿੱਚ ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਤੱਕ ਆਸਾਨ ਪਹੁੰਚ ਚਾਹੁੰਦੇ ਹਨ।

ਲੀਨਕਸ (WSL) ਲਈ ਵਿੰਡੋਜ਼ ਸਬਸਿਸਟਮ ਨੇ ਇਸ ਸਬੰਧ ਵਿਚ ਇਕ ਵੱਡਾ ਕਦਮ ਅੱਗੇ ਵਧਾਇਆ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿੰਡੋਜ਼ ਤੋਂ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਨੂੰ ਪ੍ਰੌਕਸੀ ਦੁਆਰਾ ਕਾਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ wsl.exe (ਉਦਾ.) wsl ls). ਹਾਲਾਂਕਿ ਇਹ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਹੈ, ਇਹ ਵਿਕਲਪ ਬਹੁਤ ਸਾਰੇ ਨੁਕਸਾਨਾਂ ਤੋਂ ਪੀੜਤ ਹੈ।

• ਸਰਵ ਵਿਆਪਕ ਜੋੜ wsl ਥਕਾਵਟ ਅਤੇ ਗੈਰ ਕੁਦਰਤੀ.
• ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਵਿੰਡੋਜ਼ ਪਾਥ ਹਮੇਸ਼ਾ ਕੰਮ ਨਹੀਂ ਕਰਦੇ ਕਿਉਂਕਿ ਬੈਕਸਲੈਸ਼ਾਂ ਨੂੰ ਡਾਇਰੈਕਟਰੀ ਵਿਭਾਜਕਾਂ ਦੀ ਬਜਾਏ ਬਚਣ ਵਾਲੇ ਅੱਖਰਾਂ ਵਜੋਂ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ।
• ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਵਿੰਡੋਜ਼ ਮਾਰਗਾਂ ਦਾ WSL ਵਿੱਚ ਅਨੁਸਾਰੀ ਮਾਊਂਟ ਪੁਆਇੰਟ ਵਿੱਚ ਅਨੁਵਾਦ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਉਪਨਾਮਾਂ ਅਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਵਾਲੇ WSL ਪ੍ਰੋਫਾਈਲਾਂ ਵਿੱਚ ਡਿਫੌਲਟ ਸੈਟਿੰਗਾਂ ਦਾ ਸਨਮਾਨ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਲੀਨਕਸ ਮਾਰਗ ਸੰਪੂਰਨਤਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।
• ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।
• ਆਰਗੂਮੈਂਟ ਪੂਰਾ ਕਰਨਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।

ਨਤੀਜੇ ਵਜੋਂ, ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਨੂੰ ਵਿੰਡੋਜ਼ ਦੇ ਅਧੀਨ ਦੂਜੇ ਦਰਜੇ ਦੇ ਨਾਗਰਿਕਾਂ ਵਾਂਗ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ-ਅਤੇ ਮੂਲ ਕਮਾਂਡਾਂ ਨਾਲੋਂ ਵਰਤਣਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ। ਉਨ੍ਹਾਂ ਦੇ ਅਧਿਕਾਰਾਂ ਦੀ ਬਰਾਬਰੀ ਕਰਨ ਲਈ, ਸੂਚੀਬੱਧ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ.

PowerShell ਫੰਕਸ਼ਨ ਰੈਪਰ

PowerShell ਫੰਕਸ਼ਨ ਰੈਪਰਸ ਨਾਲ, ਅਸੀਂ ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹਾਂ ਅਤੇ ਅਗੇਤਰਾਂ ਦੀ ਲੋੜ ਨੂੰ ਖਤਮ ਕਰ ਸਕਦੇ ਹਾਂ wsl, ਵਿੰਡੋਜ਼ ਮਾਰਗਾਂ ਨੂੰ WSL ਮਾਰਗਾਂ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨਾ। ਸ਼ੈੱਲਾਂ ਲਈ ਬੁਨਿਆਦੀ ਲੋੜਾਂ:

• ਹਰੇਕ ਲੀਨਕਸ ਕਮਾਂਡ ਲਈ ਇੱਕੋ ਨਾਮ ਨਾਲ ਇੱਕ ਫੰਕਸ਼ਨ ਰੈਪਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਸ਼ੈੱਲ ਨੂੰ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ 'ਤੇ ਪਾਸ ਕੀਤੇ ਵਿੰਡੋਜ਼ ਮਾਰਗਾਂ ਨੂੰ ਪਛਾਣਨਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ WSL ਮਾਰਗਾਂ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਸ਼ੈੱਲ ਨੂੰ ਕਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ wsl ਕਿਸੇ ਵੀ ਪਾਈਪਲਾਈਨ ਇੰਪੁੱਟ ਲਈ ਢੁਕਵੀਂ ਲੀਨਕਸ ਕਮਾਂਡ ਦੇ ਨਾਲ ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਕਿਸੇ ਵੀ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਨੂੰ ਪਾਸ ਕਰਨਾ।

ਕਿਉਂਕਿ ਇਹ ਪੈਟਰਨ ਕਿਸੇ ਵੀ ਕਮਾਂਡ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਸੀਂ ਇਹਨਾਂ ਰੈਪਰਾਂ ਦੀ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਸੰਖੇਪ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਹਨਾਂ ਨੂੰ ਆਯਾਤ ਕਰਨ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਸੂਚੀ ਤੋਂ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਾਂ।

# 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 ਪਾਈਪਲਾਈਨ ਇੰਪੁੱਟ ਅਤੇ ਕੋਈ ਵੀ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ।

ਇਹਨਾਂ ਰੈਪਰਾਂ ਦੇ ਨਾਲ ਤੁਸੀਂ ਆਪਣੇ ਮਨਪਸੰਦ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਨੂੰ ਇੱਕ ਅਗੇਤਰ ਜੋੜੇ ਬਿਨਾਂ ਵਧੇਰੇ ਕੁਦਰਤੀ ਤਰੀਕੇ ਨਾਲ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ wsl ਅਤੇ ਇਸ ਬਾਰੇ ਚਿੰਤਾ ਕੀਤੇ ਬਿਨਾਂ ਕਿ ਰਸਤੇ ਕਿਵੇਂ ਬਦਲੇ ਜਾਂਦੇ ਹਨ:

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

ਕਮਾਂਡਾਂ ਦਾ ਮੂਲ ਸੈੱਟ ਇੱਥੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਪਰ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਲੀਨਕਸ ਕਮਾਂਡ ਲਈ ਇਸਨੂੰ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਕੇ ਇੱਕ ਸ਼ੈੱਲ ਬਣਾ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਆਪਣੇ ਵਿੱਚ ਜੋੜਦੇ ਹੋ ਪ੍ਰੋਫਾਈਲ PowerShell, ਇਹ ਕਮਾਂਡਾਂ ਤੁਹਾਡੇ ਲਈ ਹਰ PowerShell ਸੈਸ਼ਨ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣਗੀਆਂ, ਜਿਵੇਂ ਕਿ ਮੂਲ ਕਮਾਂਡਾਂ!

ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸੈਟਿੰਗਾਂ

ਲੀਨਕਸ ਵਿੱਚ, ਲੌਗਿਨ ਪ੍ਰੋਫਾਈਲਾਂ ਵਿੱਚ ਉਪਨਾਮਾਂ ਅਤੇ/ਜਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ, ਅਕਸਰ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਕਮਾਂਡਾਂ ਲਈ ਡਿਫੌਲਟ ਪੈਰਾਮੀਟਰ ਸੈੱਟ ਕਰਨਾ (ਉਦਾਹਰਨ ਲਈ, alias ls=ls -AFh ਜ export LESS=-i). ਇੱਕ ਗੈਰ-ਇੰਟਰਐਕਟਿਵ ਸ਼ੈੱਲ ਦੁਆਰਾ ਪ੍ਰੌਕਸੀ ਕਰਨ ਦੇ ਨੁਕਸਾਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ wsl.exe - ਕਿ ਪ੍ਰੋਫਾਈਲ ਲੋਡ ਨਹੀਂ ਕੀਤੇ ਗਏ ਹਨ, ਇਸ ਲਈ ਇਹ ਵਿਕਲਪ ਮੂਲ ਰੂਪ ਵਿੱਚ ਉਪਲਬਧ ਨਹੀਂ ਹਨ (ਜਿਵੇਂ ਕਿ ls WSL ਵਿੱਚ ਅਤੇ wsl ls ਉੱਪਰ ਪਰਿਭਾਸ਼ਿਤ ਉਪਨਾਮ ਨਾਲ ਵੱਖਰਾ ਵਿਵਹਾਰ ਕਰੇਗਾ)।

PowerShell ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ $PSDefaultParameterValues, ਡਿਫੌਲਟ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਮਿਆਰੀ ਵਿਧੀ, ਪਰ ਸਿਰਫ਼ cmdlets ਅਤੇ ਉੱਨਤ ਫੰਕਸ਼ਨਾਂ ਲਈ। ਬੇਸ਼ੱਕ, ਅਸੀਂ ਆਪਣੇ ਸ਼ੈੱਲਾਂ ਤੋਂ ਉੱਨਤ ਫੰਕਸ਼ਨ ਬਣਾ ਸਕਦੇ ਹਾਂ, ਪਰ ਇਹ ਬੇਲੋੜੀਆਂ ਪੇਚੀਦਗੀਆਂ ਪੇਸ਼ ਕਰਦਾ ਹੈ (ਉਦਾਹਰਣ ਲਈ, ਪਾਵਰਸ਼ੇਲ ਅੰਸ਼ਕ ਪੈਰਾਮੀਟਰ ਨਾਮਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ (ਉਦਾਹਰਨ ਲਈ, -a ਨਾਲ ਸਬੰਧ ਰੱਖਦਾ ਹੈ -ArgumentList), ਜੋ ਕਿ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਨਾਲ ਟਕਰਾਏਗੀ ਜੋ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਅੰਸ਼ਕ ਨਾਮ ਲੈਂਦੇ ਹਨ), ਅਤੇ ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਸੰਟੈਕਸ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋਵੇਗਾ (ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ ਲਈ ਕੁੰਜੀ ਵਿੱਚ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਮ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਕਮਾਂਡ ਦਾ ਨਾਮ) .

ਹਾਲਾਂਕਿ, ਸਾਡੇ ਸ਼ੈੱਲਾਂ ਵਿੱਚ ਇੱਕ ਮਾਮੂਲੀ ਸੋਧ ਦੇ ਨਾਲ, ਅਸੀਂ ਇੱਕ ਮਾਡਲ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ $PSDefaultParameterValues, ਅਤੇ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਲਈ ਡਿਫੌਲਟ ਵਿਕਲਪਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ!

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. Bash ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ ਪ੍ਰੋਗਰਾਮੇਬਲ ਆਟੋ-ਕੰਪਲੇਸ਼ਨ ਟੂਲ. WSL ਤੁਹਾਨੂੰ PowerShell ਤੋਂ bash ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਅਸੀਂ ਆਪਣੇ PowerShell ਫੰਕਸ਼ਨ ਰੈਪਰਾਂ ਲਈ ਆਰਗੂਮੈਂਟ ਸੰਪੂਰਨਤਾਵਾਂ ਨੂੰ ਰਜਿਸਟਰ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸੰਪੂਰਨਤਾਵਾਂ ਨੂੰ ਜਨਰੇਟ ਕਰਨ ਲਈ ਬੈਸ਼ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਬੈਸ਼ ਵਾਂਗ ਹੀ ਸਟੀਕਤਾ ਨਾਲ ਪੂਰੀ ਆਰਗੂਮੈਂਟ ਸੰਪੂਰਨਤਾ ਮਿਲਦੀ ਹੈ!

# 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 ਦੇ ਆਟੋਕੰਪਲੇਸ਼ਨ ਫੰਕਸ਼ਨਾਂ ਦੁਆਰਾ ਉਮੀਦ ਕੀਤੇ ਫਾਰਮੈਟ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮੇਬਲ ਆਟੋ-ਪੂਰਨਤਾ bash
• ਅਸੀਂ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇੱਕ ਕਮਾਂਡ ਲਾਈਨ ਬਣਾਉਂਦੇ ਹਾਂ wsl.exe, ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਵਾਤਾਵਰਣ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈਟ ਅਪ ਕੀਤਾ ਗਿਆ ਹੈ, ਢੁਕਵੇਂ ਆਟੋ-ਕੰਪਲੀਸ਼ਨ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਲਾਈਨ-ਦਰ-ਲਾਈਨ ਫੈਸ਼ਨ ਵਿੱਚ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ।
• ਫਿਰ ਅਸੀਂ ਕਾਲ ਕਰਦੇ ਹਾਂ wsl ਕਮਾਂਡ ਲਾਈਨ ਦੇ ਨਾਲ, ਅਸੀਂ ਆਉਟਪੁੱਟ ਨੂੰ ਲਾਈਨ ਵਿਭਾਜਕਾਂ ਦੁਆਰਾ ਵੱਖ ਕਰਦੇ ਹਾਂ ਅਤੇ ਹਰੇਕ ਲਈ ਜਨਰੇਟ ਕਰਦੇ ਹਾਂ CompletionResults, ਉਹਨਾਂ ਨੂੰ ਛਾਂਟਣਾ ਅਤੇ ਅੱਖਰਾਂ ਤੋਂ ਬਚਣਾ ਜਿਵੇਂ ਕਿ ਸਪੇਸ ਅਤੇ ਬਰੈਕਟਸ ਜੋ ਕਿ ਨਹੀਂ ਤਾਂ ਗਲਤ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾਵੇਗੀ।

ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡੇ ਲੀਨਕਸ ਕਮਾਂਡ ਸ਼ੈੱਲ bash ਵਾਂਗ ਹੀ ਆਟੋਕੰਪਲੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਗੇ! ਉਦਾਹਰਣ ਲਈ:

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

ਹਰੇਕ ਸਵੈ-ਸੰਪੂਰਨਤਾ ਪਿਛਲੇ ਆਰਗੂਮੈਂਟ ਲਈ ਵਿਸ਼ੇਸ਼ ਮੁੱਲਾਂ ਦੀ ਸਪਲਾਈ ਕਰਦੀ ਹੈ, ਸੰਰਚਨਾ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ ਜਿਵੇਂ ਕਿ WSL ਤੋਂ ਜਾਣੇ-ਪਛਾਣੇ ਹੋਸਟ!

<TAB> ਪੈਰਾਮੀਟਰਾਂ ਰਾਹੀਂ ਚੱਕਰ ਲਵੇਗਾ। <Ctrl + пробел> ਸਾਰੇ ਉਪਲਬਧ ਵਿਕਲਪ ਦਿਖਾਏਗਾ।

ਨਾਲ ਹੀ, ਕਿਉਂਕਿ ਸਾਡੇ ਕੋਲ ਹੁਣ bash ਆਟੋਕੰਪਲੀਸ਼ਨ ਹੈ, ਤੁਸੀਂ PowerShell ਵਿੱਚ ਸਿੱਧੇ ਲੀਨਕਸ ਮਾਰਗਾਂ ਨੂੰ ਆਟੋਕੰਪਲੀਟ ਕਰ ਸਕਦੇ ਹੋ!

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

ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਜਿੱਥੇ bash ਆਟੋਕੰਪਲੀਸ਼ਨ ਕੋਈ ਨਤੀਜਾ ਨਹੀਂ ਦਿੰਦੀ ਹੈ, PowerShell ਸਿਸਟਮ ਡਿਫੌਲਟ ਵਿੰਡੋਜ਼ ਮਾਰਗਾਂ 'ਤੇ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਅਭਿਆਸ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕੋ ਸਮੇਂ ਆਪਣੇ ਵਿਵੇਕ 'ਤੇ ਦੋਵੇਂ ਮਾਰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ.

ਸਿੱਟਾ

PowerShell ਅਤੇ WSL ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਨੂੰ ਵਿੰਡੋਜ਼ ਵਿੱਚ ਮੂਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਏਕੀਕ੍ਰਿਤ ਕਰ ਸਕਦੇ ਹਾਂ। Win32 ਬਿਲਡਸ ਜਾਂ ਲੀਨਕਸ ਉਪਯੋਗਤਾਵਾਂ ਦੀ ਖੋਜ ਕਰਨ ਜਾਂ ਲੀਨਕਸ ਸ਼ੈੱਲ 'ਤੇ ਜਾ ਕੇ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਨੂੰ ਰੋਕਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ। ਬਸ WSL ਇੰਸਟਾਲ ਕਰੋ, ਕੌਂਫਿਗਰ ਕਰੋ PowerShell ਪ੍ਰੋਫਾਈਲ и ਉਹਨਾਂ ਕਮਾਂਡਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਤੁਸੀਂ ਆਯਾਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ! ਲੀਨਕਸ ਅਤੇ ਵਿੰਡੋਜ਼ ਕਮਾਂਡ ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਫਾਈਲ ਪਾਥਾਂ ਲਈ ਰਿਚ ਆਟੋਕੰਪਲੇਸ਼ਨ ਕਾਰਜਕੁਸ਼ਲਤਾ ਹੈ ਜੋ ਅੱਜ ਦੇ ਮੂਲ ਵਿੰਡੋਜ਼ ਕਮਾਂਡਾਂ ਵਿੱਚ ਵੀ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।

ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਪੂਰਾ ਸਰੋਤ ਕੋਡ, ਨਾਲ ਹੀ ਇਸਨੂੰ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਵਾਧੂ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ ਉਪਲਬਧ ਹਨ ਇੱਥੇ.

ਤੁਹਾਨੂੰ ਕਿਹੜੀਆਂ ਲੀਨਕਸ ਕਮਾਂਡਾਂ ਸਭ ਤੋਂ ਲਾਭਦਾਇਕ ਲੱਗਦੀਆਂ ਹਨ? ਵਿੰਡੋਜ਼ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਹੋਰ ਕਿਹੜੀਆਂ ਆਮ ਚੀਜ਼ਾਂ ਗੁੰਮ ਹੁੰਦੀਆਂ ਹਨ? ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ ਜਾਂ GitHub 'ਤੇ!

ਸਰੋਤ: www.habr.com