សំណួរធម្មតាពីអ្នកអភិវឌ្ឍន៍វីនដូ៖ "ហេតុអ្វីបានជានៅតែមិនមាន <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>? ថាតើវាជាការអូសដ៏មានឥទ្ធិពល less ឬឧបករណ៍ដែលធ្លាប់ស្គាល់ grep ឬ sed, អ្នកអភិវឌ្ឍន៍ Windows ចង់បានភាពងាយស្រួលនៃពាក្យបញ្ជាទាំងនេះនៅក្នុងការងារប្រចាំថ្ងៃរបស់ពួកគេ។

ប្រព័ន្ធរងវីនដូសម្រាប់លីនុច (WSL) បានបោះជំហានទៅមុខយ៉ាងធំក្នុងរឿងនេះ។ វាអនុញ្ញាតឱ្យអ្នកហៅពាក្យបញ្ជាលីនុចពីវីនដូដោយប្រូកស៊ីពួកវាតាមរយៈ wsl.exe (ឧ។ wsl ls) ទោះបីជានេះគឺជាការកែលម្អគួរឱ្យកត់សម្គាល់ក៏ដោយជម្រើសនេះទទួលរងនូវគុណវិបត្តិមួយចំនួន។

• ការបន្ថែមគ្រប់ទីកន្លែង wsl ធុញទ្រាន់និងខុសពីធម្មជាតិ។
• ផ្លូវរបស់វីនដូនៅក្នុងអាគុយម៉ង់មិនតែងតែដំណើរការទេពីព្រោះសញ្ញាថយក្រោយត្រូវបានបកស្រាយថាជាតួអក្សររត់គេចជាជាងការបំបែកថត។
• ផ្លូវរបស់វីនដូនៅក្នុងអាគុយម៉ង់មិនត្រូវបានបកប្រែទៅជាចំណុចម៉ោនដែលត្រូវគ្នានៅក្នុង WSL ទេ។
• ការកំណត់លំនាំដើមមិនត្រូវបានគោរពនៅក្នុងទម្រង់ WSL ដែលមានឈ្មោះក្លែងក្លាយ និងអថេរបរិស្ថានទេ។
• ការបញ្ចប់ផ្លូវលីនុចមិនត្រូវបានគាំទ្រទេ។
• ការបំពេញពាក្យបញ្ជាមិនត្រូវបានគាំទ្រទេ។
• ការបញ្ចប់អាគុយម៉ង់មិនត្រូវបានគាំទ្រទេ។

ជាលទ្ធផល ពាក្យបញ្ជាលីនុចត្រូវបានចាត់ទុកដូចជាពលរដ្ឋលំដាប់ទីពីរនៅក្រោមវីនដូ ហើយពិបាកប្រើជាងពាក្យបញ្ជាដើម។ ដើម្បីឱ្យស្មើគ្នានូវសិទ្ធិរបស់ពួកគេ វាចាំបាច់ក្នុងការដោះស្រាយបញ្ហាដែលបានរាយបញ្ជី។

ឧបករណ៍រុំមុខងារ PowerShell

ជាមួយកម្មវិធីរុំមុខងារ PowerShell យើងអាចបន្ថែមការបំពេញពាក្យបញ្ជា និងលុបបំបាត់តម្រូវការសម្រាប់បុព្វបទ wslបកប្រែផ្លូវ Windows ទៅជាផ្លូវ WSL ។ តម្រូវការមូលដ្ឋានសម្រាប់សែល៖

• សម្រាប់រាល់ពាក្យបញ្ជាលីនុចត្រូវតែមានមុខងាររុំមួយដែលមានឈ្មោះដូចគ្នា។
• សែលត្រូវតែទទួលស្គាល់ផ្លូវ Windows ដែលបានឆ្លងកាត់ជាអាគុយម៉ង់ ហើយបំប្លែងវាទៅជាផ្លូវ 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 (ដោយ​ដំបូង​លុប​ឈ្មោះ​ក្លែងក្លាយ​ណា​មួយ​ដែល​នឹង​មាន​ជម្លោះ​ជាមួយ​មុខងារ)។

មុខងារធ្វើម្តងទៀតលើអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា កំណត់ផ្លូវរបស់ Windows ដោយប្រើពាក្យបញ្ជា 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 និងមុខងារកម្រិតខ្ពស់ប៉ុណ្ណោះ។ ជាការពិតណាស់ យើងអាចបង្កើតមុខងារកម្រិតខ្ពស់ចេញពីសែលរបស់យើង ប៉ុន្តែនេះណែនាំភាពស្មុគស្មាញដែលមិនចាំបាច់ (ឧទាហរណ៍ PowerShell ទាក់ទងឈ្មោះប៉ារ៉ាម៉ែត្រផ្នែកខ្លះ (ឧទាហរណ៍ -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. អត្ថប្រយោជន៍បន្ថែមនៃតារាង hash ដាច់ដោយឡែកគឺសមត្ថភាពក្នុងការបិទ $WslDefaultParameterValues ដោយឡែកពីគ្នា។ $PSDefaultParameterValues.

ការបញ្ចប់អាគុយម៉ង់

PowerShell អនុញ្ញាតឱ្យអ្នកចុះឈ្មោះឈុតខ្លីៗដោយប្រើពាក្យបញ្ជា 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 ប៉ុន្តែជាមូលដ្ឋានដែលយើងធ្វើគឺនេះ៖

• ការចុះឈ្មោះការបញ្ចប់អាគុយម៉ង់សម្រាប់កម្មវិធីរុំមុខងាររបស់យើងទាំងអស់ដោយឆ្លងកាត់បញ្ជីមួយ។ $commands នៅក្នុងប៉ារ៉ាម៉ែត្រ -CommandName សម្រាប់ Register-ArgumentCompleter.
• យើងគូសផែនទីពាក្យបញ្ជានីមួយៗទៅនឹងមុខងារសែលដែល bash ប្រើសម្រាប់ការបំពេញដោយស្វ័យប្រវត្តិ (ដើម្បីកំណត់លក្ខណៈបច្ចេកទេសនៃការបំពេញដោយស្វ័យប្រវត្តិ bash ប្រើ $F, អក្សរកាត់សម្រាប់ complete -F <FUNCTION>).
• ការបំប្លែងអាគុយម៉ង់ PowerShell $wordToComplete, $commandAst и $cursorPosition ចូលទៅក្នុងទម្រង់ដែលរំពឹងទុកដោយមុខងារបំពេញស្វ័យប្រវត្តិរបស់ 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 ត្រឡប់ទៅផ្លូវលំនាំដើមរបស់ប្រព័ន្ធ Windows ។ ដូច្នេះក្នុងការអនុវត្ត អ្នកអាចប្រើផ្លូវទាំងពីរក្នុងពេលដំណាលគ្នាតាមការសំរេចចិត្តរបស់អ្នក។

សេចក្តីសន្និដ្ឋាន

ដោយប្រើ PowerShell និង WSL យើងអាចបញ្ចូលពាក្យបញ្ជាលីនុចទៅក្នុង Windows ជាកម្មវិធីដើម។ មិនចាំបាច់ស្វែងរក Win32 builds ឬ Linux Utilities ឬរំខានដំណើរការការងាររបស់អ្នកដោយចូលទៅកាន់ Linux Shell នោះទេ។ គ្រាន់តែ ដំឡើង WSL, កំណត់រចនាសម្ព័ន្ធ កម្រងព័ត៌មាន PowerShell и រាយពាក្យបញ្ជាដែលអ្នកចង់នាំចូល! ការបំពេញដោយស្វ័យប្រវត្តិដ៏សម្បូរបែបសម្រាប់ប៉ារ៉ាម៉ែត្រពាក្យបញ្ជារបស់លីនុច និងវីនដូ និងផ្លូវឯកសារគឺជាមុខងារដែលមិនមាននៅក្នុងពាក្យបញ្ជាវីនដូដើមសព្វថ្ងៃនេះទេ។

កូដប្រភពពេញលេញដែលបានពិពណ៌នាខាងលើ ក៏ដូចជាគោលការណ៍ណែនាំបន្ថែមសម្រាប់ការបញ្ចូលវាទៅក្នុងលំហូរការងាររបស់អ្នកមាន នៅទីនេះ.

តើពាក្យបញ្ជាលីនុចមួយណាដែលអ្នកយល់ថាមានប្រយោជន៍បំផុត? តើមានអ្វីទូទៅផ្សេងទៀតដែលបាត់នៅពេលធ្វើការនៅក្នុង Windows? សរសេរនៅក្នុងមតិយោបល់ឬ នៅលើ GitHub!

ប្រភព: www.habr.com