Take notes on the command line: Difference between revisions

{{task|Text processing}} {{selection|Short Circuit|Console Program Basics}}[[Category:Basic language learning]] [[Category:Programming environment operations]]

{{omit from|Lotus 123 Macro Scripting}}

{{omit from|Maxima}}

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

 

I :argv.len == 1

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

E

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}}

 

A:\></pre>

 

=={{header|Ada}}==

{{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

 

<tt>"c:\program files\j602\bin\jconsole.exe" path\to\script\notes.ijs</tt><br>

and Start in: <tt>.\</tt>

 

=={{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}}==

 

=={{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:

try:

shutil.copyfileobj(f, sys.stdout)

except IOError:

pass

else:

 

'''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}}

Test line 3

</pre>

 

=={{header|REXX}}==

 

 

 

=={{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>

 

=={{header|uBasic/4tH}}==

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

g@ = g@ - FUNC(_Monthdays (c@-1, f@))

' Print a@, d@, e@, f@

 

_TimeStr ' convert epoch to time string

Param (1)

 

_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

Anyways, it seems this task is DONE!

</pre>

=={{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).

 

var dateFormatIn = "yyyy|-|mm|-|dd|+|hh|:|MM"

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

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

 

{{out}}

2021-09-29 16:51

my second note

</pre>

 

=={{header|zkl}}==

File notes.zkl:

args:=vm.arglist;

if (not args)

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

f.close();

{{out}}

<pre>