Take notes on the command line: Difference between revisions

=={{header|11l}}==

I :argv.len == 1

print(File(‘notes.txt’).read(), end' ‘’)

V f = File(‘notes.txt’, ‘a’)

f.write(Time().format("YYYY-MM-DD hh:mm:ss\n"))

=={{header|8086 Assembly}}==

This code assembles into a .COM file that runs under MS-DOS.

cpu 8086

;;; MS-DOS PSP locations

filnam: db 'NOTES.TXT',0 ; File name to use

section .bss

{{out}}

{{works with|Ada 2005}}

with Ada.Characters.Latin_1;

with Ada.Command_Line;

Ada.Text_IO.Close (File => Notes_File);

end if;

=={{header|Aime}}==

if (argc() == 1) {

f.byte('\n');

=={{header|APL}}==

{{works with|GNU APL}}

∇r←ch Join ls ⍝ Join list of strings with character

Notes

{{out}}

=={{header|AppleScript}}==

Requires a modernish version of OS X (Lion or later) on which osascript works as a shebang interpreter.

-- format a number as a string with leading zero if needed

end try

end if

=={{header|Arturo}}==

if? empty? arg [

if exists? notes -> print read notes

"\t" ++ (join.with:" " to [:string] arg) ++ "\n"

write.append notes output

{{out}}

=={{header|AutoHotkey}}==

If 0 = 0 ; no arguments

FileAppend, `r`n, %Notes%

=={{header|AWK}}==

# syntax: GAWK -f TAKE_NOTES.AWK [notes ... ]

# examples:

printf("\n") >>log_name

}

{{out}} from the three example commands:

<pre>

for this to work with older versions of QB.

OPEN "notes.txt" FOR APPEND AS 1

PRINT #1, DATE$, TIME$

CLOSE

END IF

=={{header|Batch File}}==

{{works with|Windows NT|4}}

if %1@==@ (

if exist notes.txt more notes.txt

)

echo %date% %time%:>>notes.txt

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

This must be compiled to an EXE and run from the command prompt.

REM!Embed

LF = 10

CLOSE #notes%

=={{header|C}}==

#include <time.h>

if (note) fclose(note);

return 0;

=={{header|C sharp|C#}}==

using System.IO;

using System.Text;

}

}

=={{header|C++}}==

#include <iostream>

#include <ctime>

}

}

=={{header|Clojure}}==

(:use [clojure.string :only [join]]))

(println (slurp "NOTES.txt"))))

{{out}}

=={{header|CLU}}==

% PCLU in "useful.lib".

else add_note(note)

end

{{out}}

<pre>$ ls

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. NOTES.

GOBACK

=={{header|Common Lisp}}==

(defun format-date-time (stream)

(defun main ()

=={{header|D}}==

import std.stdio, std.file, std.datetime, std.range;

f.writefln("\t%-(%s %)", args.dropOne);

}

{{out}}

<pre>C:\>notes Permission to speak, sir!

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

sw.Free;

end;

=={{header|E}}==

def f := <file:notes.txt>

w.close()

}

=={{header|Elixir}}==

{{trans|Erlang}}

@filename "NOTES.TXT"

end

=={{header|Erlang}}==

#! /usr/bin/env escript

Existing_contents = file_contents(),

file:write_file( file(), [Existing_contents, Notes, "\n"] ).

=={{header|Euphoria}}==

constant filename = "notes.txt"

integer fn

puts(fn,line)

close(fn)

=={{header|F Sharp|F#}}==

open System.IO;;

| 0 -> show_notes()

| _ -> take_note <| String.concat " " args;

Usage:

=={{header|Factor}}==

USING: kernel calendar calendar.format io io.encodings.utf8 io.files

sequences command-line namespaces ;

print flush

] with-file-appender

=={{header|Fantom}}==

class Notes

{

}

}

Sample:

The following is SwiftForth-specific, and runs in the Forth environment rather than as a standalone terminal application. Win32Forth only needs simple replacements of DATE and TIME . A Unix Forth would come closer to the 'commandline' requirement, as Windows Forths for whatever reason very eagerly discard the Windows console. Because this runs in the Forth environment, the otherwise acceptable application words are stuffed in a wordlist. Standard Forth doesn't have the notion of create-it-if-it-doesn't-exist, so OPEN just tries again with CREATE-FILE if OPEN-FILE fails.

get-current also note-words definitions

open 0 parse dup if add-note

else 2drop dump then close ;

The following is exactly the same program, but written in 4tH. 4tH has an I/O system which is different from ANS-Forth. The notes file is specified on the commandline.

include lib/argopen.4th

include lib/ansfacil.4th

refill drop 0 parse dup if add-note else 2drop dump then ;

=={{header|Fortran}}==

program notes

implicit none

endif

end program notes

{{out}}<pre>

2022-2-20T18:40:13

=={{header|FreeBASIC}}==

Open "notes.txt" For Append As #1

Print #1, Date, Time

End If

Close #1

=={{header|Gambas}}==

Public Sub Main()

Endif

Output:

<pre>

=={{header|Go}}==

import (

os.Exit(1)

}

=={{header|Groovy}}==

if (args) {

notes << "${new Date().format('YYYY-MM-dd HH:mm:ss')}\t${args.join(' ')}\n"

println notes.text

}

=={{header|Haskell}}==

import System.Time (getClockTime)

else

do ct <- getClockTime

{{out}} after a few runs:

=={{header|HicEst}}==

CHARACTER notes="Notes.txt", txt*1000

ENDIF

<pre>Thu 2010-09-16 18:42:15

This is line 1

=={{header|Icon}} and {{header|Unicon}}==

procedure write_out_notes (filename)

file := open (filename, "rt") | stop ("no notes file yet")

else add_to_notes (notes_file, args)

end

{{out}}

=={{header|J}}==

'''Solution''':<br>

notes=: monad define

notes 2}.ARGV

Create a Shortcut called <tt>Notes</tt> that calls the script above using the Target:<br>

=={{header|Java}}==

import java.nio.channels.*;

import java.util.Date;

}

}

=={{header|JavaScript}}==

{{works with|JScript}}

var args = WScript.Arguments;

f.WriteLine();

f.Close();

<pre>> del NOTES.TXT

> cscript /nologo notes.js

=={{header|Julia}}==

const filename = "NOTES.TXT"

end

close(fp)

=={{header|Kotlin}}==

import java.io.File

f.appendText(notes)

}

Sample output:

=={{header|Lasso}}==

local(

else

#notesfile -> exists ? stdout(#notesfile -> readstring)

Called with:

./notes First Second Last

./notes

<pre>2013-11-15 11:43:08

Rosetta was here, Räksmörgås

=={{header|Lua}}==

if #arg == 0 then

fp:close()

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Print[ReadString[str, EndOfFile]]; Close[str],

str = OpenAppend["NOTES.TXT"]; WriteLine[str, DateString[]];

WriteLine[str, "\t" <> StringRiffle[$CommandLine[[11 ;;]]]];

=={{header|MATLAB}} / {{header|Octave}}==

% NOTES can be used for taking notes

% usage:

fprintf(fid,'\n');

fclose(fid);

=={{header|Mercury}}==

:- interface.

notes_filename = "NOTES.TXT".

=={{header|Nim}}==

if paramCount() == 0:

f.writeLine getTime()

f.writeLine "\t", commandLineParams().join(" ")

Sample format.txt:

<pre>2021-04-21T15:49:00+02:00

=={{header|OCaml}}==

#load "unix.cma"

if Array.length Sys.argv = 1

then dump_notes()

=={{header|Oz}}==

import

Application

end

{Application.exit 0}

=={{header|Pascal}}==

Free Pascal in Delphi mode or Delphi in console mode.

{$mode delphi}

PROGRAM notes;

END;

END.

{{out|Program usage and output}}

=={{header|Perl}}==

if ( @ARGV ) {

open NOTES, '>>', $file or die "Can't append to file $file: $!";

print <NOTES>;

}

{{out}} after a few runs:

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">command_line</span><span style="color: #0000FF;">(),</span>

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{header|PHP}}==

#!/usr/bin/php

<?php

else

@readfile('notes.txt');

Note that the error suppression operator (@) is considered bad coding practice.

=={{header|PicoLisp}}==

(load "@lib/misc.l")

(out "+notes.txt" (prinl (stamp) "^J^I" (glue " " @)))

(and (info "notes.txt") (in "notes.txt" (echo))) )

=={{header|PL/I}}==

declare text character (100) varying;

declare note_file file;

put file (note_file) skip;

put skip list ('The file, NOTES.TXT, has been created');

=={{header|PowerShell}}==

if (($args).length -eq 0) {

if(Test-Path $notes) {

Get-Date | Add-Content $notes

"`t" + $args -join " " | Add-Content $notes

=={{header|PureBasic}}==

Define argc=CountProgramParameters()

If OpenConsole()

EndIf

EndIf

=={{header|Python}}==

if len(sys.argv) == 1:

with open('notes.txt', 'a') as f:

f.write(datetime.datetime.now().isoformat() + '\n')

'''Sample notes.txt file'''

=={{header|R}}==

args <- commandArgs(trailingOnly=TRUE)

cat(file=conn, date(), "\n\t", paste(args, collapse=" "), "\n", sep="")

}

=={{header|Racket}}==

#!/usr/bin/env racket

#lang racket

(date->string (current-date) #t)

(string-join notes))))))

=={{header|Raku}}==

(formerly Perl 6)

multi MAIN() {

$fh.say: DateTime.now, "\n\t", @note;

$fh.close;

=={{header|REBOL}}==

Title: "Notes"

URL: http://rosettacode.org/wiki/Take_notes_on_the_command_line

] [

write/binary/append notes rejoin [now lf tab args lf]

{{out|Sample session}}

=={{header|REXX}}==

timestamp=right(date(),11,0) time() date('W') /*create a (current) date & time stamp.*/

nFID = 'NOTES.TXT' /*the fileID of the "notes" file. */

call lineout nFID,tab||arg(1) /* " " text " " " */

end

=={{header|Ruby}}==

if ARGV.empty?

File.copy_stream(notes, $stdout) rescue nil

else

File.open(notes, 'a') {|file| file.puts "%s\n\t%s" % [Time.now, ARGV.join(' ')]}

=={{header|Rust}}==

This uses version 0.4 of the <code>chrono</code> crate

use std::fs::OpenOptions;

add_to_notes(&note.join(" ")).expect("failed to write to NOTES.TXT");

}

=={{header|Scala}}==

{{libheader|Scala}}

import java.time.LocalDateTime

}

}

=={{header|Scheme}}==

(moved from Racket)

{{works with|Racket}}

(require racket/date)

(define *notes* "NOTES.TXT")

(fprintf fo "~a~n\t~a~n" dt ln)))

#:mode 'text #:exists 'append)

=={{header|Seed7}}==

$ include "getf.s7i";

$ include "time.s7i";

end if;

end if;

=={{header|Sidef}}==

if (ARGV.len > 0) {

var fh = file.open_r

fh && fh.each { .say }

{{out}}

<pre>

=={{header|SNOBOL4}}==

{{works with|Macro SNOBOL4 in C}}

a = 2 ;* skip '-b' parameter

notefile = "notes.txt"

notes = date()

notes = char(9) args

=={{header|Swift}}==

let args = Process.arguments

let strData = str.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)

{{out}}

Example output

=={{header|Tcl}}==

set notefile notes.txt

close $f

}

{{out}} after a few runs:

<pre>

{{works with|R3}}

The lack of built-in high level time and date functions makes it more difficult than necessary, since they have to be implemented by user defined functions.

If Set (a, Open ("notes.txt", "a")) < 0 Then

Print "Cannot write \qnotes.txt\q" ' open the file in "append" mode

_Format Param (2) : Return (Join (Iif (a@<10, Join(b@, "0"), b@), Str (a@)))

_Monthdays Param (2) : Return (((a@ + (a@<7)) % 2) + 30 - ((2 - b@) * (a@=1)))

{{out}}

<pre>2022-04-02 14:58:57

=={{header|UNIX Shell}}==

Bash version

NOTES=$HOME/notes.txt

if [[ $# -eq 0 ]] ; then

date >> $NOTES

echo " $*" >> $NOTES

"Spoiled Bash kid" version

Portable version

if test "x$*" = "x"

then

date >> $NOTES

echo " $*" >> $NOTES

{{omit from|Retro}}

=={{header|Visual Basic .NET}}==

Module Notes

End Try

End Function

=={{header|Wren}}==

An awkward task for Wren-cli which currently has no way of determining the current date and time.

We therefore have to ask the user to input it plus the note(s).

import "/ioutil" for File, FileUtil

import "/date" for Date

var note = "\t" + args[1..-1].join(" ") + "\n"

FileUtil.append("NOTES.TXT", dateTime.format(dateFormatOut) + "\n" + note)

{{out}}

=={{header|XPL0}}==

Checks for unlikely array overflows have been omitted for simplicity.

int I, NotesSize, Ch, CmdArgSize;

char Notes(1_000_000), CmdArg(1000);

Close(3);

];

{{out}}

=={{header|zkl}}==

File notes.zkl:

args:=vm.arglist;

if (not args)

f.writeln(Time.Date.ctime(),"\n\t",args.concat(" "));

f.close();

{{out}}

<pre>