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

If NOTES.TXT doesn't already exist in the current directory then a new NOTES.TXT file should be created.

 

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

text s;

 

 

o_(s, "\n");

}

} else {

date d;

file f;

d.m_day, d.d_hour, d.h_minute, d.m_second);

 

}

 

f.byte('\n');

 

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

#include <iostream>

#include <ctime>

}

}

 

=={{header|Clojure}}==

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

 

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

 

 

{{out}}

 

</pre>

 

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

 

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:

else:

var f = open("notes.txt", fmAppend)

Sample format.txt:

Hello World

Hello World again</pre>

 

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

</pre>

 

 

 

 

 

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

2010-04-01T17:08:20.718000

go for it</pre>

 

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

Thu Apr 01 19:28:49 BST 2010

TODO: Submit notes.tcl to Rosetta Code

</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|zkl}}==

File notes.zkl:

args:=vm.arglist;

if (not args)

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

f.close();

{{out}}

<pre>