ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > ಪವರ್‌ಶೆಲ್ ಮತ್ತು ಡಬ್ಲ್ಯುಎಸ್‌ಎಲ್ ಬಳಸಿ ವಿಂಡೋಸ್‌ಗೆ ಲಿನಕ್ಸ್ ಆಜ್ಞೆಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ಪವರ್‌ಶೆಲ್ ಮತ್ತು ಡಬ್ಲ್ಯುಎಸ್‌ಎಲ್ ಬಳಸಿ ವಿಂಡೋಸ್‌ಗೆ ಲಿನಕ್ಸ್ ಆಜ್ಞೆಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ವಿಂಡೋಸ್ ಡೆವಲಪರ್‌ಗಳಿಂದ ಒಂದು ವಿಶಿಷ್ಟವಾದ ಪ್ರಶ್ನೆ: “ಯಾಕೆ ಇನ್ನೂ ಇಲ್ಲ <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. ಇದು ಶಕ್ತಿಯುತ ಸ್ವೈಪ್ ಆಗಿರಲಿ less ಅಥವಾ ಪರಿಚಿತ ಉಪಕರಣಗಳು grep ಅಥವಾ sed, ವಿಂಡೋಸ್ ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ದೈನಂದಿನ ಕೆಲಸದಲ್ಲಿ ಈ ಆಜ್ಞೆಗಳಿಗೆ ಸುಲಭ ಪ್ರವೇಶವನ್ನು ಬಯಸುತ್ತಾರೆ.

ಲಿನಕ್ಸ್ (WSL) ಗಾಗಿ ವಿಂಡೋಸ್ ಉಪವ್ಯವಸ್ಥೆ ಈ ನಿಟ್ಟಿನಲ್ಲಿ ಬಹುದೊಡ್ಡ ಹೆಜ್ಜೆಯನ್ನಿಟ್ಟಿದೆ. ವಿಂಡೋಸ್‌ನಿಂದ ಲಿನಕ್ಸ್ ಆಜ್ಞೆಗಳನ್ನು ಪ್ರಾಕ್ಸಿ ಮಾಡುವ ಮೂಲಕ ಕರೆ ಮಾಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ wsl.exe (ಉದಾ. wsl ls) ಇದು ಗಮನಾರ್ಹ ಸುಧಾರಣೆಯಾಗಿದ್ದರೂ, ಈ ಆಯ್ಕೆಯು ಹಲವಾರು ಅನಾನುಕೂಲತೆಗಳಿಂದ ಬಳಲುತ್ತಿದೆ.

  • ಸರ್ವತ್ರ ಸೇರ್ಪಡೆ wsl ಬೇಸರದ ಮತ್ತು ಅಸ್ವಾಭಾವಿಕ.
  • ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಲ್ಲಿನ ವಿಂಡೋಸ್ ಪಥಗಳು ಯಾವಾಗಲೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್‌ಗಳನ್ನು ಡೈರೆಕ್ಟರಿ ವಿಭಜಕಗಳಿಗಿಂತ ಎಸ್ಕೇಪ್ ಕ್ಯಾರೆಕ್ಟರ್‌ಗಳಾಗಿ ಅರ್ಥೈಸಲಾಗುತ್ತದೆ.
  • ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಲ್ಲಿನ ವಿಂಡೋಸ್ ಪಥಗಳನ್ನು WSL ನಲ್ಲಿ ಅನುಗುಣವಾದ ಮೌಂಟ್ ಪಾಯಿಂಟ್‌ಗೆ ಅನುವಾದಿಸಲಾಗಿಲ್ಲ.
  • ಅಲಿಯಾಸ್ ಮತ್ತು ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳೊಂದಿಗೆ WSL ಪ್ರೊಫೈಲ್‌ಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಗೌರವಿಸಲಾಗುವುದಿಲ್ಲ.
  • Linux ಮಾರ್ಗ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.
  • ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಗೆ ಬೆಂಬಲವಿಲ್ಲ.
  • ವಾದವನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

ಪರಿಣಾಮವಾಗಿ, ಲಿನಕ್ಸ್ ಆಜ್ಞೆಗಳನ್ನು ವಿಂಡೋಸ್ ಅಡಿಯಲ್ಲಿ ಎರಡನೇ ದರ್ಜೆಯ ನಾಗರಿಕರಂತೆ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ - ಮತ್ತು ಸ್ಥಳೀಯ ಆಜ್ಞೆಗಳಿಗಿಂತ ಬಳಸಲು ಹೆಚ್ಚು ಕಷ್ಟ. ಅವರ ಹಕ್ಕುಗಳನ್ನು ಸಮೀಕರಿಸಲು, ಪಟ್ಟಿ ಮಾಡಲಾದ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ.

ಪವರ್‌ಶೆಲ್ ಕಾರ್ಯ ಹೊದಿಕೆಗಳು

PowerShell ಫಂಕ್ಷನ್ ಹೊದಿಕೆಗಳೊಂದಿಗೆ, ನಾವು ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತು ಪೂರ್ವಪ್ರತ್ಯಯಗಳ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕಬಹುದು wsl, ವಿಂಡೋಸ್ ಪಥಗಳನ್ನು WSL ಪಥಗಳಾಗಿ ಭಾಷಾಂತರಿಸುವುದು. ಚಿಪ್ಪುಗಳಿಗೆ ಮೂಲಭೂತ ಅವಶ್ಯಕತೆಗಳು:

  • ಪ್ರತಿ Linux ಆಜ್ಞೆಗೆ ಒಂದೇ ಹೆಸರಿನೊಂದಿಗೆ ಒಂದು ಕಾರ್ಯ ಹೊದಿಕೆ ಇರಬೇಕು.
  • ಶೆಲ್ ವಿಂಡೋಸ್ ಪಥಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ಗುರುತಿಸಬೇಕು ಮತ್ತು ಅವುಗಳನ್ನು 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 ಪೈಪ್ಲೈನ್ ​​ಇನ್ಪುಟ್ ಮತ್ತು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು.

ಈ ಹೊದಿಕೆಗಳೊಂದಿಗೆ ನೀವು ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಸೇರಿಸದೆಯೇ ನಿಮ್ಮ ಮೆಚ್ಚಿನ Linux ಆಜ್ಞೆಗಳನ್ನು ಹೆಚ್ಚು ನೈಸರ್ಗಿಕ ರೀತಿಯಲ್ಲಿ ಕರೆಯಬಹುದು wsl ಮತ್ತು ಮಾರ್ಗಗಳನ್ನು ಹೇಗೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಚಿಂತಿಸದೆ:

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

ಆಜ್ಞೆಗಳ ಮೂಲ ಸೆಟ್ ಅನ್ನು ಇಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ, ಆದರೆ ಪಟ್ಟಿಗೆ ಸೇರಿಸುವ ಮೂಲಕ ನೀವು ಯಾವುದೇ ಲಿನಕ್ಸ್ ಆದೇಶಕ್ಕಾಗಿ ಶೆಲ್ ಅನ್ನು ರಚಿಸಬಹುದು. ನಿಮ್ಮ ಈ ಕೋಡ್ ಅನ್ನು ನೀವು ಸೇರಿಸಿದರೆ ಪ್ರೊಫೈಲ್ ಪವರ್‌ಶೆಲ್, ಸ್ಥಳೀಯ ಆಜ್ಞೆಗಳಂತೆಯೇ ಪ್ರತಿ ಪವರ್‌ಶೆಲ್ ಅಧಿವೇಶನದಲ್ಲಿ ಈ ಆಜ್ಞೆಗಳು ನಿಮಗೆ ಲಭ್ಯವಿರುತ್ತವೆ!

ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು

Linux ನಲ್ಲಿ, ಲಾಗಿನ್ ಪ್ರೊಫೈಲ್‌ಗಳಲ್ಲಿ ಅಲಿಯಾಸ್‌ಗಳು ಮತ್ತು/ಅಥವಾ ಪರಿಸರದ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆಗಾಗ್ಗೆ ಬಳಸುವ ಆಜ್ಞೆಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, 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. ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮ್ಮ ಪವರ್‌ಶೆಲ್ ಪ್ರೊಫೈಲ್‌ಗೆ ಸೂಚನೆಗಳನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು ಎಂಬುದನ್ನು ಕೆಳಗಿನವು ತೋರಿಸುತ್ತದೆ. ಈಗ ನಾವು ಅದನ್ನು ಮಾಡಬಹುದು!

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

ನಿಯತಾಂಕಗಳನ್ನು ಮಾದರಿಯಾಗಿರುವುದರಿಂದ $PSDefaultParameterValues, ನೀನು ಮಾಡಬಲ್ಲೆ ಅವುಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದು ಸುಲಭ ಕೀಲಿಯನ್ನು ಸ್ಥಾಪಿಸುವ ಮೂಲಕ ತಾತ್ಕಾಲಿಕವಾಗಿ "Disabled" ಅರ್ಥದಲ್ಲಿ $true. ಪ್ರತ್ಯೇಕ ಹ್ಯಾಶ್ ಟೇಬಲ್‌ನ ಹೆಚ್ಚುವರಿ ಪ್ರಯೋಜನವೆಂದರೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯ $WslDefaultParameterValues ಪ್ರತ್ಯೇಕವಾಗಿ $PSDefaultParameterValues.

ವಾದವನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು

ಪವರ್‌ಶೆಲ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಆರ್ಗ್ಯುಮೆಂಟ್ ಟ್ರೇಲರ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ Register-ArgumentCompleter. ಬ್ಯಾಷ್ ಶಕ್ತಿಯುತವಾಗಿದೆ ಪ್ರೊಗ್ರಾಮೆಬಲ್ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಉಪಕರಣಗಳು. ಪವರ್‌ಶೆಲ್‌ನಿಂದ ಬ್ಯಾಷ್‌ಗೆ ಕರೆ ಮಾಡಲು 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>).
  • ಪವರ್‌ಶೆಲ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸಲಾಗುತ್ತಿದೆ $wordToComplete, $commandAst и $cursorPosition ವಿಶೇಷಣಗಳ ಪ್ರಕಾರ ಬ್ಯಾಷ್‌ನ ಸ್ವಯಂಪೂರ್ಣತೆಯ ಕಾರ್ಯಗಳಿಂದ ನಿರೀಕ್ಷಿಸಲಾದ ಸ್ವರೂಪಕ್ಕೆ ಪ್ರೊಗ್ರಾಮೆಬಲ್ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಬಾಷ್.
  • ವರ್ಗಾಯಿಸಲು ನಾವು ಆಜ್ಞಾ ಸಾಲನ್ನು ರಚಿಸುತ್ತೇವೆ wsl.exe, ಇದು ಪರಿಸರವನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಸೂಕ್ತವಾದ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಲೈನ್-ಬೈ-ಲೈನ್ ಶೈಲಿಯಲ್ಲಿ ನೀಡುತ್ತದೆ.
  • ನಂತರ ನಾವು ಕರೆ ಮಾಡುತ್ತೇವೆ wsl ಆಜ್ಞಾ ಸಾಲಿನೊಂದಿಗೆ, ನಾವು ಔಟ್ಪುಟ್ ಅನ್ನು ಲೈನ್ ವಿಭಜಕಗಳ ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸುತ್ತೇವೆ ಮತ್ತು ಪ್ರತಿಯೊಂದಕ್ಕೂ ಉತ್ಪಾದಿಸುತ್ತೇವೆ CompletionResults, ಅವುಗಳನ್ನು ವಿಂಗಡಿಸುವುದು ಮತ್ತು ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಬಹುದಾದ ಸ್ಪೇಸ್‌ಗಳು ಮತ್ತು ಆವರಣಗಳಂತಹ ಅಕ್ಷರಗಳಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳುವುದು.

ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಲಿನಕ್ಸ್ ಕಮಾಂಡ್ ಶೆಲ್‌ಗಳು ಬ್ಯಾಷ್‌ನಂತೆಯೇ ಅದೇ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಬಳಸುತ್ತವೆ! ಉದಾಹರಣೆಗೆ:

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

ಪ್ರತಿ ಸ್ವಯಂಪೂರ್ಣತೆಯು ಹಿಂದಿನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಮೌಲ್ಯಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ, WSL ನಿಂದ ತಿಳಿದಿರುವ ಹೋಸ್ಟ್‌ಗಳಂತಹ ಕಾನ್ಫಿಗರೇಶನ್ ಡೇಟಾವನ್ನು ಓದುತ್ತದೆ!

<TAB> ನಿಯತಾಂಕಗಳ ಮೂಲಕ ಸೈಕಲ್ ಮಾಡುತ್ತದೆ. <Ctrl + пробел> ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಆಯ್ಕೆಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

ಜೊತೆಗೆ, ನಾವು ಈಗ ಬ್ಯಾಷ್ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ನೀವು ನೇರವಾಗಿ ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಲಿನಕ್ಸ್ ಮಾರ್ಗಗಳನ್ನು ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸಬಹುದು!

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

ಬ್ಯಾಷ್ ಸ್ವಯಂಪೂರ್ಣತೆಯು ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡದ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಪವರ್‌ಶೆಲ್ ಸಿಸ್ಟಮ್ ಡೀಫಾಲ್ಟ್ ವಿಂಡೋಸ್ ಪಥಗಳಿಗೆ ಹಿಂತಿರುಗುತ್ತದೆ. ಹೀಗಾಗಿ, ಪ್ರಾಯೋಗಿಕವಾಗಿ, ನಿಮ್ಮ ವಿವೇಚನೆಯಿಂದ ನೀವು ಏಕಕಾಲದಲ್ಲಿ ಎರಡೂ ಮಾರ್ಗಗಳನ್ನು ಬಳಸಬಹುದು.

ತೀರ್ಮಾನಕ್ಕೆ

ಪವರ್‌ಶೆಲ್ ಮತ್ತು ಡಬ್ಲ್ಯುಎಸ್‌ಎಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಲಿನಕ್ಸ್ ಆಜ್ಞೆಗಳನ್ನು ವಿಂಡೋಸ್‌ಗೆ ಸ್ಥಳೀಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾಗಿ ಸಂಯೋಜಿಸಬಹುದು. Win32 ಬಿಲ್ಡ್‌ಗಳು ಅಥವಾ ಲಿನಕ್ಸ್ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಹುಡುಕುವ ಅಗತ್ಯವಿಲ್ಲ ಅಥವಾ ಲಿನಕ್ಸ್ ಶೆಲ್‌ಗೆ ಹೋಗುವ ಮೂಲಕ ನಿಮ್ಮ ಕೆಲಸದ ಹರಿವನ್ನು ಅಡ್ಡಿಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಕೇವಲ WSL ಅನ್ನು ಸ್ಥಾಪಿಸಿ, ಕಾನ್ಫಿಗರ್ ಮಾಡಿ ಪವರ್‌ಶೆಲ್ ಪ್ರೊಫೈಲ್ и ನೀವು ಆಮದು ಮಾಡಲು ಬಯಸುವ ಆಜ್ಞೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ! Linux ಮತ್ತು Windows ಕಮಾಂಡ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಮತ್ತು ಫೈಲ್ ಪಾತ್‌ಗಳಿಗಾಗಿ ಶ್ರೀಮಂತ ಸ್ವಯಂಪೂರ್ಣತೆಯು ಇಂದು ಸ್ಥಳೀಯ ವಿಂಡೋಸ್ ಆಜ್ಞೆಗಳಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲದ ಕಾರ್ಯವಾಗಿದೆ.

ಮೇಲೆ ವಿವರಿಸಿದ ಪೂರ್ಣ ಮೂಲ ಕೋಡ್, ಹಾಗೆಯೇ ಅದನ್ನು ನಿಮ್ಮ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಸೇರಿಸಲು ಹೆಚ್ಚುವರಿ ಮಾರ್ಗಸೂಚಿಗಳು ಲಭ್ಯವಿದೆ ಇಲ್ಲಿ.

ಯಾವ Linux ಆಜ್ಞೆಗಳು ನಿಮಗೆ ಹೆಚ್ಚು ಉಪಯುಕ್ತವೆಂದು ತೋರುತ್ತದೆ? ವಿಂಡೋಸ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಇತರ ಯಾವ ಸಾಮಾನ್ಯ ವಿಷಯಗಳು ಕಾಣೆಯಾಗಿವೆ? ಕಾಮೆಂಟ್ಗಳಲ್ಲಿ ಬರೆಯಿರಿ ಅಥವಾ GitHub ನಲ್ಲಿ!

ಮೂಲ: www.habr.com

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ