เปิดแท็บ Terminal ใหม่จากบรรทัดคำสั่ง (Mac OS X)


116

เป็นไปได้ไหมที่จะเปิดแท็บใหม่ในเทอร์มินัลของ Mac OS X จากบรรทัดคำสั่งในแท็บที่เปิดอยู่

ฉันรู้ว่าแป้นพิมพ์ลัดเพื่อเปิดแท็บใหม่ใน Terminal คือ "CMD + t" แต่ฉันกำลังมองหาโซลูชันที่ใช้สคริปต์ที่ดำเนินการในบรรทัดคำสั่ง

คำตอบ:


126

ลองสิ่งนี้:

osascript -e 'tell application "Terminal" to activate' -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'

D'Oh! ฉันพลาดความคิดเห็นของคุณโดยสิ้นเชิงพบวิธีแก้ปัญหาที่คล้ายกันผ่านทาง Google ความแตกต่างอย่างหนึ่ง: มันไม่ได้ผลสำหรับฉัน (ในวันที่ 10.6.8) เว้นแต่ Terminal จะเป็นแอปพลิเคชันที่อยู่หน้าสุดดังนั้นฉันจึงเพิ่ม "เปิดใช้งาน" เพื่อบังคับให้ไปด้านหน้า
Gordon Davisson

5
แก้ไข: ฉันจะใส่คำสั่งecho helloใหม่ในแท็บใหม่นี้ได้อย่างไร
ThomasReggi

22
@ThomasReggi: เพิ่ม-e 'tell application "Terminal" to do script "echo hello" in selected tab of the front window'ที่ส่วนท้ายของคำสั่ง osascript
Gordon Davisson

2
@clevertension สำหรับ iTerm มันเป็นเพียงopen -a iTerm ~/Applications/
onmyway133

1
@Ciastopiekarz คุณหมายถึงในแท็บที่เพิ่งเปิดใหม่ใช่หรือไม่? ใช้วิธีการเดียวกับคำตอบของฉัน ThomasReggi: -e 'tell application "Terminal" to do script "cd /path/to/target/directory" in selected tab of the front window'เพิ่ม โปรดทราบว่าหากเส้นทางนั้นมาจากตัวแปรคุณจะต้องใช้สตริงที่มีเครื่องหมายอัญประกาศคู่แทนการยกมาครั้งเดียวและหลีกเลี่ยงสตริงที่ยกมาด้านในและอาจเป็นเส้นทางนั้นเอง
Gordon Davisson

163

อัปเดต : คำตอบนี้ได้รับความนิยมจากฟังก์ชันเชลล์ที่โพสต์ด้านล่างซึ่งยังคงใช้งานได้เหมือน OSX 10.10 (ยกเว้น-gตัวเลือก)
อย่างไรก็ตามเวอร์ชันสคริปต์ที่ผ่านการทดสอบที่มีคุณลักษณะครบถ้วนและมีประสิทธิภาพยิ่งขึ้นมีให้บริการttabแล้วที่รีจิสตรี npmในชื่อ CLIซึ่งรองรับiTerm2 :

  • หากคุณติดตั้งNode.jsให้เรียกใช้:

    npm install -g ttab
    

    (ขึ้นอยู่กับว่าคุณติดตั้ง Node.js อย่างไรคุณอาจต้องใส่ไว้sudoข้างหน้า)

  • มิฉะนั้นทำตามคำแนะนำเหล่านี้

  • เมื่อติดตั้งแล้วให้เรียกttab -hใช้ข้อมูลการใช้งานที่กระชับหรือman ttabดูคู่มือ


จากคำตอบที่ยอมรับด้านล่างนี้เป็นฟังก์ชั่นอำนวยความสะดวก bash สำหรับการเปิดแท็บใหม่ในหน้าต่าง Terminal ปัจจุบันและเรียกใช้คำสั่ง (เป็นโบนัสมีฟังก์ชันตัวแปรสำหรับการสร้างหน้าต่างใหม่แทน)

หากระบุคำสั่งโทเค็นแรกจะถูกใช้เป็นหัวเรื่องของแท็บใหม่

ตัวอย่างการเรียกร้อง:

    # Get command-line help.
newtab -h
    # Simpy open new tab.
newtab
    # Open new tab and execute command (quoted parameters are supported).
newtab ls -l "$Home/Library/Application Support"
    # Open a new tab with a given working directory and execute a command;
    # Double-quote the command passed to `eval` and use backslash-escaping inside.
newtab eval "cd ~/Library/Application\ Support; ls"
    # Open new tab, execute commands, close tab.
newtab eval "ls \$HOME/Library/Application\ Support; echo Press a key to exit.; read -s -n 1; exit"
    # Open new tab and execute script.
newtab /path/to/someScript
    # Open new tab, execute script, close tab.
newtab exec /path/to/someScript
    # Open new tab and execute script, but don't activate the new tab.
newtab -G /path/to/someScript

CAVEAT : เมื่อคุณเรียกใช้newtab(หรือnewwin) จากสคริปต์โฟลเดอร์การทำงานเริ่มต้นของสคริปต์จะเป็นโฟลเดอร์การทำงานในแท็บ / หน้าต่างใหม่แม้ว่าคุณจะเปลี่ยนโฟลเดอร์การทำงานภายในสคริปต์ก่อนที่จะเรียกใช้newtab/ newwin- ส่งผ่านevalด้วยcdคำสั่งเป็นวิธีแก้ปัญหา (ดูตัวอย่างด้านบน)

ซอร์สโค้ด (วางลงในโปรไฟล์ทุบตีของคุณเป็นต้น):

# Opens a new tab in the current Terminal window and optionally executes a command.
# When invoked via a function named 'newwin', opens a new Terminal *window* instead.
function newtab {

    # If this function was invoked directly by a function named 'newwin', we open a new *window* instead
    # of a new tab in the existing window.
    local funcName=$FUNCNAME
    local targetType='tab'
    local targetDesc='new tab in the active Terminal window'
    local makeTab=1
    case "${FUNCNAME[1]}" in
        newwin)
            makeTab=0
            funcName=${FUNCNAME[1]}
            targetType='window'
            targetDesc='new Terminal window'
            ;;
    esac

    # Command-line help.
    if [[ "$1" == '--help' || "$1" == '-h' ]]; then
        cat <<EOF
Synopsis:
    $funcName [-g|-G] [command [param1 ...]]

Description:
    Opens a $targetDesc and optionally executes a command.

    The new $targetType will run a login shell (i.e., load the user's shell profile) and inherit
    the working folder from this shell (the active Terminal tab).
    IMPORTANT: In scripts, \`$funcName\` *statically* inherits the working folder from the
    *invoking Terminal tab* at the time of script *invocation*, even if you change the
    working folder *inside* the script before invoking \`$funcName\`.

    -g (back*g*round) causes Terminal not to activate, but within Terminal, the new tab/window
      will become the active element.
    -G causes Terminal not to activate *and* the active element within Terminal not to change;
      i.e., the previously active window and tab stay active.

    NOTE: With -g or -G specified, for technical reasons, Terminal will still activate *briefly* when
    you create a new tab (creating a new window is not affected).

    When a command is specified, its first token will become the new ${targetType}'s title.
    Quoted parameters are handled properly.

    To specify multiple commands, use 'eval' followed by a single, *double*-quoted string
    in which the commands are separated by ';' Do NOT use backslash-escaped double quotes inside
    this string; rather, use backslash-escaping as needed.
    Use 'exit' as the last command to automatically close the tab when the command
    terminates; precede it with 'read -s -n 1' to wait for a keystroke first.

    Alternatively, pass a script name or path; prefix with 'exec' to automatically
    close the $targetType when the script terminates.

Examples:
    $funcName ls -l "\$Home/Library/Application Support"
    $funcName eval "ls \\\$HOME/Library/Application\ Support; echo Press a key to exit.; read -s -n 1; exit"
    $funcName /path/to/someScript
    $funcName exec /path/to/someScript
EOF
        return 0
    fi

    # Option-parameters loop.
    inBackground=0
    while (( $# )); do
        case "$1" in
            -g)
                inBackground=1
                ;;
            -G)
                inBackground=2
                ;;
            --) # Explicit end-of-options marker.
                shift   # Move to next param and proceed with data-parameter analysis below.
                break
                ;;
            -*) # An unrecognized switch.
                echo "$FUNCNAME: PARAMETER ERROR: Unrecognized option: '$1'. To force interpretation as non-option, precede with '--'. Use -h or --h for help." 1>&2 && return 2
                ;;
            *)  # 1st argument reached; proceed with argument-parameter analysis below.
                break
                ;;
        esac
        shift
    done

    # All remaining parameters, if any, make up the command to execute in the new tab/window.

    local CMD_PREFIX='tell application "Terminal" to do script'

        # Command for opening a new Terminal window (with a single, new tab).
    local CMD_NEWWIN=$CMD_PREFIX    # Curiously, simply executing 'do script' with no further arguments opens a new *window*.
        # Commands for opening a new tab in the current Terminal window.
        # Sadly, there is no direct way to open a new tab in an existing window, so we must activate Terminal first, then send a keyboard shortcut.
    local CMD_ACTIVATE='tell application "Terminal" to activate'
    local CMD_NEWTAB='tell application "System Events" to keystroke "t" using {command down}'
        # For use with -g: commands for saving and restoring the previous application
    local CMD_SAVE_ACTIVE_APPNAME='tell application "System Events" to set prevAppName to displayed name of first process whose frontmost is true'
    local CMD_REACTIVATE_PREV_APP='activate application prevAppName'
        # For use with -G: commands for saving and restoring the previous state within Terminal
    local CMD_SAVE_ACTIVE_WIN='tell application "Terminal" to set prevWin to front window'
    local CMD_REACTIVATE_PREV_WIN='set frontmost of prevWin to true'
    local CMD_SAVE_ACTIVE_TAB='tell application "Terminal" to set prevTab to (selected tab of front window)'
    local CMD_REACTIVATE_PREV_TAB='tell application "Terminal" to set selected of prevTab to true'

    if (( $# )); then # Command specified; open a new tab or window, then execute command.
            # Use the command's first token as the tab title.
        local tabTitle=$1
        case "$tabTitle" in
            exec|eval) # Use following token instead, if the 1st one is 'eval' or 'exec'.
                tabTitle=$(echo "$2" | awk '{ print $1 }') 
                ;;
            cd) # Use last path component of following token instead, if the 1st one is 'cd'
                tabTitle=$(basename "$2")
                ;;
        esac
        local CMD_SETTITLE="tell application \"Terminal\" to set custom title of front window to \"$tabTitle\""
            # The tricky part is to quote the command tokens properly when passing them to AppleScript:
            # Step 1: Quote all parameters (as needed) using printf '%q' - this will perform backslash-escaping.
        local quotedArgs=$(printf '%q ' "$@")
            # Step 2: Escape all backslashes again (by doubling them), because AppleScript expects that.
        local cmd="$CMD_PREFIX \"${quotedArgs//\\/\\\\}\""
            # Open new tab or window, execute command, and assign tab title.
            # '>/dev/null' suppresses AppleScript's output when it creates a new tab.
        if (( makeTab )); then
            if (( inBackground )); then
                # !! Sadly, because we must create a new tab by sending a keystroke to Terminal, we must briefly activate it, then reactivate the previously active application.
                if (( inBackground == 2 )); then # Restore the previously active tab after creating the new one.
                    osascript -e "$CMD_SAVE_ACTIVE_APPNAME" -e "$CMD_SAVE_ACTIVE_TAB" -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" -e "$cmd in front window" -e "$CMD_SETTITLE" -e "$CMD_REACTIVATE_PREV_APP" -e "$CMD_REACTIVATE_PREV_TAB" >/dev/null
                else
                    osascript -e "$CMD_SAVE_ACTIVE_APPNAME" -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" -e "$cmd in front window" -e "$CMD_SETTITLE" -e "$CMD_REACTIVATE_PREV_APP" >/dev/null
                fi
            else
                osascript -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" -e "$cmd in front window" -e "$CMD_SETTITLE" >/dev/null
            fi
        else # make *window*
            # Note: $CMD_NEWWIN is not needed, as $cmd implicitly creates a new window.
            if (( inBackground )); then
                # !! Sadly, because we must create a new tab by sending a keystroke to Terminal, we must briefly activate it, then reactivate the previously active application.
                if (( inBackground == 2 )); then # Restore the previously active window after creating the new one.
                    osascript -e "$CMD_SAVE_ACTIVE_WIN" -e "$cmd" -e "$CMD_SETTITLE" -e "$CMD_REACTIVATE_PREV_WIN" >/dev/null
                else
                    osascript -e "$cmd" -e "$CMD_SETTITLE" >/dev/null
                fi
            else
                    # Note: Even though we do not strictly need to activate Terminal first, we do it, as assigning the custom title to the 'front window' would otherwise sometimes target the wrong window.
                osascript -e "$CMD_ACTIVATE" -e "$cmd" -e "$CMD_SETTITLE" >/dev/null
            fi
        fi        
    else    # No command specified; simply open a new tab or window.
        if (( makeTab )); then
            if (( inBackground )); then
                # !! Sadly, because we must create a new tab by sending a keystroke to Terminal, we must briefly activate it, then reactivate the previously active application.
                if (( inBackground == 2 )); then # Restore the previously active tab after creating the new one.
                    osascript -e "$CMD_SAVE_ACTIVE_APPNAME" -e "$CMD_SAVE_ACTIVE_TAB" -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" -e "$CMD_REACTIVATE_PREV_APP" -e "$CMD_REACTIVATE_PREV_TAB" >/dev/null
                else
                    osascript -e "$CMD_SAVE_ACTIVE_APPNAME" -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" -e "$CMD_REACTIVATE_PREV_APP" >/dev/null
                fi
            else
                osascript -e "$CMD_ACTIVATE" -e "$CMD_NEWTAB" >/dev/null
            fi
        else # make *window*
            if (( inBackground )); then
                # !! Sadly, because we must create a new tab by sending a keystroke to Terminal, we must briefly activate it, then reactivate the previously active application.
                if (( inBackground == 2 )); then # Restore the previously active window after creating the new one.
                    osascript -e "$CMD_SAVE_ACTIVE_WIN" -e "$CMD_NEWWIN" -e "$CMD_REACTIVATE_PREV_WIN" >/dev/null
                else
                    osascript -e "$CMD_NEWWIN" >/dev/null
                fi
            else
                    # Note: Even though we do not strictly need to activate Terminal first, we do it so as to better visualize what is happening (the new window will appear stacked on top of an existing one).
                osascript -e "$CMD_ACTIVATE" -e "$CMD_NEWWIN" >/dev/null
            fi
        fi
    fi

}

# Opens a new Terminal window and optionally executes a command.
function newwin {
    newtab "$@" # Simply pass through to 'newtab', which will examine the call stack to see how it was invoked.
}

3
@jcollum ความสุขของฉัน; ดีใจที่พบว่ามีประโยชน์ ฉันเพิ่งอัปเดตโพสต์ด้วยคำเตือนโฟลเดอร์ที่ใช้งานได้และอัปเดตรหัส: เพิ่มตัวเลือก-g(อย่าเปิดใช้งาน Terminal เมื่อสร้างแท็บ / หน้าต่างใหม่) และ-G(อย่าเปิดใช้งาน Terminal และอย่าเปลี่ยนแท็บที่ใช้งานอยู่ภายใน Terminal ) - มีประโยชน์เช่นเมื่อเริ่มเซิร์ฟเวอร์ในพื้นหลัง โปรดทราบว่าเมื่อสร้างแท็บใหม่ด้วยวิธีนี้ Terminal ยังคงต้องเปิดใช้งานสั้น ๆ ก่อนที่แอปพลิเคชันที่ใช้งานอยู่ก่อนหน้านี้จะเปิดใช้งานอีกครั้ง
mklement0

1
@Leonardo แท็บใหม่มีไดเร็กทอรีการทำงานเหมือนกับแท็บที่เรียกใช้ฟังก์ชัน การเปลี่ยนไปใช้โฟลเดอร์อื่นภายในสคริปต์ก่อนที่จะเรียกnewtabใช้งานไม่ได้ วิธีแก้ปัญหาคือส่งevalคำสั่งที่มีcdคำสั่งไปที่newtab; เช่น: newtab eval "cd ~/Library/Application\ Support; ls". อ้างสองครั้งที่คำสั่งทั้งหมดที่ส่งไปยังevalและใช้แบ็กสแลช - เอสเคป
mklement0

1
@IntegrityFirst: ตามคำแนะนำของคุณฉันได้เปลี่ยนลายเซ็นของฟังก์ชันเป็นfunction newtabและfunction newwin(อย่างไรก็ตามไม่มีวงเล็บ) ดังนั้นจึงควรหลีกเลี่ยงการชนกับนามแฝงเมื่อกำหนดฟังก์ชัน แต่โปรดทราบว่าในการเรียกใช้นามแฝงที่มีชื่อเดียวกันจะมีความสำคัญ (ถึง บายพาสนามแฝงเฉพาะกิจพูดส่วนหนึ่งของชื่อฟังก์ชั่นใด ๆ เช่น: \newtab)
mklement0

2
@IntegrityFirst: นี่คือสิ่งที่ผมได้เรียนรู้: การใช้ POSIX <name>() { ... }ไวยากรณ์ฟังก์ชั่นที่ทำให้<name>อาจมีการขยายตัวนามแฝงซึ่งแบ่งนิยามฟังก์ชัน (แยกข้อผิดพลาด!) ถ้านามแฝง<name>ที่เกิดขึ้นมีการกำหนดไว้ โดยทั่วไปไม่น่ากังวลเนื่องจากในการขยายนามแฝงสคริปต์ที่เรียกตามปกติจะถูกปิดโดยค่าเริ่มต้น อย่างไรก็ตามในสคริปต์ที่มาจากเชลล์แบบโต้ตอบ - เช่นในไฟล์โปรไฟล์ / การเริ่มต้น - การขยายนามแฝงเปิดอยู่ แก้ไข: ใช้function <name> { ... } ไวยากรณ์ที่ไม่ใช่ POSIX เพื่อกำหนดฟังก์ชัน - <name>จากนั้นจะไม่อยู่ภายใต้การขยายนามแฝง
mklement0

1
ขอบคุณ! นี้เพิ่มif [ "${BASH_SOURCE}" == "${0}" ]ด้วยกับคำสั่งกรณีจึงสามารถเรียกว่าเป็นสคริปต์ (เช่นnewtab.sh, newwin.sh): gist.github.com/westurner/01b6be85e5a51fda22a6
เวสเทอร์เนอ

18

นี่คือวิธีการทำโดยbash_it :

function tab() {
  osascript 2>/dev/null <<EOF
    tell application "System Events"
      tell process "Terminal" to keystroke "t" using command down
    end
    tell application "Terminal"
      activate
      do script with command "cd \"$PWD\"; $*" in window 1
    end tell
EOF
}

หลังจากเพิ่มสิ่งนี้ใน. bash_profile ของคุณคุณจะต้องใช้ไฟล์ tabคำสั่งเพื่อเปิดไดเร็กทอรีการทำงานปัจจุบันในแท็บใหม่

ดู: https://github.com/revans/bash-it/blob/master/plugins/available/osx.plugin.bash#L3


1
เป็นประโยชน์มาก เมื่อใช้สิ่งนี้ใน. bash_profile ของฉันฉันสามารถเปิดแท็บและ ssh ให้พวกเขาได้โดยอัตโนมัติ แน่นอนฉันเปิดใช้งานการตรวจสอบสิทธิ์คู่คีย์ ssh แล้ว
Sandeep Kanabar

16
osascript -e 'tell app "Terminal"
   do script "echo hello"
end tell'

สิ่งนี้จะเปิดเทอร์มินัลใหม่และรันคำสั่ง "echo hello" ที่อยู่ข้างใน


3
วิธีนี้ใช้งานได้ แต่แท็บใหม่ถูกสร้างขึ้นในอินสแตนซ์แยกต่างหากของ Terminal อย่างไรก็ตามแท็บใหม่ยังคงอยู่ในอินสแตนซ์ปัจจุบันของ Terminal ของฉันหรือไม่
Calvin Cheng

อย่างไรก็ตามคุณสามารถใช้do script ""กับสตริงว่างเพื่อสร้างเทอร์มินัลใหม่โดยไม่ต้องออกคำสั่ง
Chris Page

9

หากคุณใช้oh-my-zsh (ซึ่งคนอินเทรนด์ทุกคนควรใช้) หลังจากเปิดใช้งานปลั๊กอิน "osx" .zshrcแล้วให้ป้อนtabคำสั่ง มันจะเปิดแท็บใหม่และcdในไดเร็กทอรีที่คุณอยู่


มันดูน่าสนใจมาก อะไรคือความแตกต่างระหว่าง zcsh และ bash ทั่วไป?
Calvin Cheng

มีลักษณะคล้ายกันมาก แต่ที่น่าสนใจที่สุดคือมีการเติมแท็บที่ชาญฉลาดมีประสิทธิภาพและการแก้ไขอัตโนมัติ ดูเปรียบเทียบที่ดีที่นี่ Oh-my-zsh กำลังตั้งค่าสภาพแวดล้อมด้วยการตั้งค่า / ปลั๊กอินที่ดีและสะดวกเพื่อให้คุณเริ่มต้น
CharlesB

ลองดูลิงค์เปรียบเทียบของ CharlesB อย่างรวดเร็ว น่าสนใจมาก. ฟังดูเหมือนเปลือก BPython กับเปลือก iPython
Calvin Cheng

zsh พยายามที่จะหลีกเลี่ยงปัญหาที่เก่าแก่มากขึ้นเพื่อสูญเสียการควบคุม
James

คุณสามารถให้ข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ได้หรือไม่? คำสั่ง tab คืออะไร? การเข้ามาtabดูเหมือนจะไม่ทำอะไรเลย
Solvitieg

7

แป้นพิมพ์ลัดจะcmd-tเปิดแท็บใหม่คุณจึงสามารถส่งต่อการกดแป้นพิมพ์นี้ไปยังคำสั่ง OSA ได้ดังนี้:

osascript -e 'tell application "System Events"' -e 'keystroke "t" using command down' -e 'end tell'


6

ฉันเพิ่มสิ่งเหล่านี้ลงใน. bash_profile เพื่อให้ฉันสามารถเข้าถึง tabname และ newtab ได้

tabname() {
  printf "\e]1;$1\a"
}

new_tab() {
  TAB_NAME=$1
  COMMAND=$2
  osascript \
    -e "tell application \"Terminal\"" \
    -e "tell application \"System Events\" to keystroke \"t\" using {command down}" \
    -e "do script \"printf '\\\e]1;$TAB_NAME\\\a'; $COMMAND\" in front window" \
    -e "end tell" > /dev/null
}

ดังนั้นเมื่อคุณอยู่ในแท็บใดแท็บหนึ่งคุณสามารถพิมพ์ได้

tabname "New TabName"

เพื่อจัดระเบียบแท็บที่เปิดอยู่ทั้งหมดที่คุณมี จะดีกว่าการรับข้อมูลบนแท็บและเปลี่ยนแปลงที่นั่นมาก


ขอบคุณ คุณรู้วิธีรักษาชื่อแท็บหลังจากที่ฉันทำ ssh จากแท็บและออกจากเซสชัน ssh หรือไม่
anjanb

4

ฉันรู้ว่านี่เป็นโพสต์เก่า แต่สิ่งนี้ใช้ได้กับฉัน:

open -a Terminal "`pwd`"

ในการเรียกใช้คำสั่งตามที่ร้องขอด้านล่างต้องใช้ jiggery:

echo /sbin/ping 8.8.8.8 > /tmp/tmp.sh;chmod a+x /tmp/tmp.sh;open -a Terminal /tmp/tmp.sh

ดีมาก! ฉันจะทำอย่างไรหากต้องการส่งคำสั่งที่จะทำงานในอินสแตนซ์ใหม่ของ Terminal : D
Strazan

@Strazan แก้ไขคำตอบด้านบน ... สนุก !! ดูเหมือนเทอร์มินัลจะรับพารามิเตอร์แบบนั้น ...
นีโอไฟต์

3

เมื่อคุณอยู่ในหน้าต่างเทอร์มินัลคำสั่ง + n => เปิดเทอร์มินัลใหม่และคำสั่ง + t => เปิดแท็บใหม่ในหน้าต่างเทอร์มินัลปัจจุบัน


1
สิ่งนี้ต้องทำงานจากบรรทัดคำสั่ง โดยพื้นฐานแล้วสคริปต์ เพราะมันเป็นงานที่ซ้ำซาก
Gianfranco P.

2

หากคุณใช้iTermคำสั่งนี้จะเปิดแท็บใหม่:

osascript -e 'tell application "iTerm" to activate' -e 'tell application "System Events" to tell process "iTerm" to keystroke "t" using command down'

หากคุณต้องการเพิ่มสิ่งนี้ลงใน. zshrc หรือ. bashrc คุณสามารถทำได้โดยใช้ฟังก์ชันแทนนามแฝง (เนื่องจากการหลบหนีทั้งหมดคุณจะต้องทำ) stackoverflow.com/a/20111135/1401336
Vigrant

@Andrew Schreiber: แต่ตัวควบคุมไม่ได้ถ่ายโอนไปยังแท็บใหม่ ฉันหมายถึงถ้าคุณมีรหัสหลังจากเปิดแท็บใหม่รหัสนั้นจะถูกเรียกใช้ในแท็บเดิม มีวิธีบอกให้สคริปต์ประมวลผลคำสั่งต่อไปนี้ในแท็บใหม่หรือไม่?
Ashwin


0

สิ่งที่เกี่ยวกับตัวอย่างง่ายๆนี้ตามคำสั่งสคริปต์มาตรฐาน (echo):

# set mac osx's terminal title to "My Title"
echo -n -e "\033]0;My Title\007"

0

เมื่อติดตั้ง X แล้ว (เช่นจาก homebrew หรือ Quartz) "xterm &" ที่เรียบง่ายจะทำ (เกือบ) เคล็ดลับมันจะเปิดหน้าต่างเทอร์มินัลใหม่ (ไม่ใช่แท็บ)

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.