Windows ๊ฐ๋ฐ์์ ์ผ๋ฐ์ ์ธ ์ง๋ฌธ: โ์ ์์ง๋ <ะะกะขะะะฌะขะ ะขะฃะข ะะฎะะะะฃะฎ ะะะะะะะฃ LINUX>
?. ๊ฐ๋ ฅํ ์ค์์ดํ์ธ์ง less
๋๋ ์ต์ํ ๋๊ตฌ grep
๋๋ sed
, Windows ๊ฐ๋ฐ์๋ ์ผ์ ์
๋ฌด์์ ์ด๋ฌํ ๋ช
๋ น์ ์ฝ๊ฒ ์ก์ธ์คํ๊ธฐ๋ฅผ ์ํฉ๋๋ค.
wsl.exe
(์ : wsl ls
). ์ด๋ ์๋นํ ๊ฐ์ ์ด๊ธฐ๋ ํ์ง๋ง, ์ด ์ต์
์๋ ์ฌ๋ฌ ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค.
- ์ ๋น์ฟผํฐ์ค ์ถ๊ฐ
wsl
์ง๋ฃจํ๊ณ ๋ถ์์ฐ ์ค๋ฝ์ต๋๋ค. - ๋ฐฑ์ฌ๋์๊ฐ ๋๋ ํฐ๋ฆฌ ๊ตฌ๋ถ ๊ธฐํธ๊ฐ ์๋ ์ด์ค์ผ์ดํ ๋ฌธ์๋ก ํด์๋๊ธฐ ๋๋ฌธ์ ์ธ์์ Windows ๊ฒฝ๋ก๊ฐ ํญ์ ์๋ํ๋ ๊ฒ์ ์๋๋๋ค.
- ์ธ์์ Windows ๊ฒฝ๋ก๋ WSL์ ํด๋น ํ์ฌ ์ง์ ์ผ๋ก ๋ณํ๋์ง ์์ต๋๋ค.
- ๋ณ์นญ ๋ฐ ํ๊ฒฝ ๋ณ์๊ฐ ์๋ WSL ํ๋กํ์์๋ ๊ธฐ๋ณธ ์ค์ ์ด ์กด์ค๋์ง ์์ต๋๋ค.
- Linux ๊ฒฝ๋ก ์์ฑ์ ์ง์๋์ง ์์ต๋๋ค.
- ๋ช ๋ น ์์ฑ์ ์ง์๋์ง ์์ต๋๋ค.
- ์ธ์ ์์ฑ์ ์ง์๋์ง ์์ต๋๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก Linux ๋ช ๋ น์ Windows์์ XNUMX๋ฑ๊ธ ์๋ฏผ์ฒ๋ผ ์ทจ๊ธ๋๋ฉฐ ๊ธฐ๋ณธ ๋ช ๋ น๋ณด๋ค ์ฌ์ฉํ๊ธฐ๊ฐ ๋ ์ด๋ ต์ต๋๋ค. ๊ทธ๋ค์ ๊ถ๋ฆฌ๋ฅผ ๊ท ๋ฑํํ๋ ค๋ฉด ๋์ด๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผ ํฉ๋๋ค.
PowerShell ํจ์ ๋ํผ
PowerShell ํจ์ ๋ํผ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ช
๋ น ์์ฑ์ ์ถ๊ฐํ๊ณ ์ ๋์ฌ์ ํ์์ฑ์ ์ ๊ฑฐํ ์ ์์ต๋๋ค. wsl
, Windows ๊ฒฝ๋ก๋ฅผ WSL ๊ฒฝ๋ก๋ก ๋ณํํฉ๋๋ค. ์์ ๊ธฐ๋ณธ ์๊ตฌ ์ฌํญ:
- ๋ชจ๋ Linux ๋ช ๋ น์๋ ๋์ผํ ์ด๋ฆ์ ๊ฐ์ง ํ๋์ ํจ์ ๋ํผ๊ฐ ์์ด์ผ ํฉ๋๋ค.
- ์ ธ์ ์ธ์๋ก ์ ๋ฌ๋ 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 ๋ช
๋ น์ ๋ํ ์
ธ์ ๋ง๋ค ์ ์์ต๋๋ค. ์ด ์ฝ๋๋ฅผ
๊ธฐ๋ณธ ์ค์
Linux์์๋ ๋ก๊ทธ์ธ ํ๋กํ์ ๋ณ์นญ ๋ฐ/๋๋ ํ๊ฒฝ ๋ณ์๋ฅผ ์ ์ํ๊ณ ์์ฃผ ์ฌ์ฉํ๋ ๋ช
๋ น์ ๋ํ ๊ธฐ๋ณธ ๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์
๋๋ค(์: alias ls=ls -AFh
๋๋ export LESS=-i
). ๋น๋ํํ ์์ ํตํ ํ๋ก์ฑ์ ๋จ์ ์ค ํ๋ wsl.exe
- ํ๋กํ์ด ๋ก๋๋์ง ์์ผ๋ฏ๋ก ๊ธฐ๋ณธ์ ์ผ๋ก ์ด๋ฌํ ์ต์
์ ์ฌ์ฉํ ์ ์์ต๋๋ค(์: ls
WSL์์ wsl ls
์์ ์ ์๋ ๋ณ์นญ๊ณผ ๋ค๋ฅด๊ฒ ๋์ํฉ๋๋ค).
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
. ๋ฐฐ์ฌ๋ ๊ฐ๋ ฅํ๋ค
# 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
๋งค๊ฐ๋ณ์์์-CommandName
์Register-ArgumentCompleter
. - 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 ์๋ ์์ฑ ๊ธฐ๋ฅ์ด ์์ผ๋ฏ๋ก PowerShell์์ ์ง์ Linux ๊ฒฝ๋ก๋ฅผ ์๋ ์์ฑํ ์ ์์ต๋๋ค!
less /etc/<TAB>
ls /usr/share/<TAB>
vim ~/.bash<TAB>
Bash ์๋ ์์ฑ์ผ๋ก ๊ฒฐ๊ณผ๊ฐ ์์ฑ๋์ง ์๋ ๊ฒฝ์ฐ PowerShell์ ์์คํ ๊ธฐ๋ณธ Windows ๊ฒฝ๋ก๋ก ๋๋์๊ฐ๋๋ค. ๋ฐ๋ผ์ ์ค์ ๋ก๋ ์ฌ๋์ ๋ฐ๋ผ ๋ ๊ฒฝ๋ก๋ฅผ ๋์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก
PowerShell๊ณผ WSL์ ์ฌ์ฉํ๋ฉด Linux ๋ช
๋ น์ ๊ธฐ๋ณธ ์ ํ๋ฆฌ์ผ์ด์
์ผ๋ก Windows์ ํตํฉํ ์ ์์ต๋๋ค. Win32 ๋น๋ ๋๋ Linux ์ ํธ๋ฆฌํฐ๋ฅผ ๊ฒ์ํ๊ฑฐ๋ Linux ์
ธ๋ก ์ด๋ํ์ฌ ์์
ํ๋ฆ์ ์ค๋จํ ํ์๊ฐ ์์ต๋๋ค. ๋จ์ง
์์ ์ค๋ช
๋ ์ ์ฒด ์์ค ์ฝ๋์ ์ด๋ฅผ ์ํฌํ๋ก์ ํตํฉํ๊ธฐ ์ํ ์ถ๊ฐ ์ง์นจ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ด๋ค Linux ๋ช
๋ น์ด ๊ฐ์ฅ ์ ์ฉํ๋ค๊ณ ์๊ฐํ์๋์? Windows์์ ์์
ํ ๋ ๋๋ฝ๋ ๋ค๋ฅธ ์ผ๋ฐ์ ์ธ ์ฌํญ์ ๋ฌด์์
๋๊น? ๋๊ธ๋ก ์ ์ด์ฃผ์๊ฑฐ๋
์ถ์ฒ : habr.com