#PHP if else shorthand

[infoanalysishub]

PHP Shorthand if Statements

Learn PHP shorthand if statements (ternary operator) with syntax, examples, use cases, and best practices. Simplify your PHP code using concise conditionals. Mastering PHP Shorthand if Statements (Ternary Operator) PHP offers several ways to write conditional statements, and one of the most concise and powerful is the shorthand if statement, also known as the ternary operator. This feature…

[foxgraphics325]

Unix Regex Cheat Sheet

Grep Regex Cheat Sheet

Perl Regex Cheat Sheet Pdf

Unix Regex Cheat Sheet Download

Unix Regex Cheat Sheet Example

A regular expression, regex or regexp is a sequence of characters that define a search pattern. Usually such patterns are used by string searching algorithms for 'find' or 'find and replace' operations on strings, or for input validation.

Cheat Sheet This cheat sheet is intended to be a quick reminder for the main concepts involved in using regular expressions and assumes you already understand their usage. If you are new to regular expressions we strongly suggest you work through the Regular Expressions tutorial from the beginning.

Regular Expressions Cheat Sheet by DaveChild - Cheatography.com Created Date: 4237Z. Name Command; Insert string to the begining of lines: sed -i 's/^/head /g' my-file: Insert string to the end of lines: sed -i 's/$/ tail/g' my-file: Add content after nth line.

characters — what to seek

ring matches ring, springboard, ringtone, etc.

. matches almost any character

h.o matches hoo, h2o, h/o, etc.

Use to search for these special characters:

( ^ $ . | ? * + ( ) ( )

ring? matches ring?

(quiet) matches (quiet)

c:windows matches c:windows

alternatives — | (OR)

cat|dog match cat or dog

order matters if short alternative is part of longer

id|identity matches id or identity

regex engine is 'eager', stops comparing as soon as 1st alternative matches

identity|id matches id or identity

order longer to shorter when alternatives overlap

(To match whole words, see scope and groups.)

character classes — (allowed) or (^NOT allowed)

(aeiou) match any vowel

(^aeiou) match a NON vowel

r(iau)ng match ring, wrangle, sprung, etc.

gr(ae)y match gray or grey

(a-zA-Z0-9) match any letter or digit

(In ( ) always escape . ) and sometimes ^ - .)

shorthand classes

w 'word' character (letter, digit, or underscore)

d digit

s whitespace (space, tab, vtab, newline)

W, D, or S, (NOT word, digit, or whitespace)

(DS) means not digit OR whitespace, both match

(^ds) disallow digit AND whitespace

occurrences — ? * + (n) (n,) (n,n)

? 0 or 1

colou?r match color or colour

* 0 or more

(BW)ill(ieamy's)* match Bill, Willy, William's etc.

+ 1 or more

(a-zA-Z)+ match 1 or more letters

(n) require n occurrences

d(3)-d(2)-d(4) match a SSN

(n,) require n or more

(a-zA-Z)(2,) 2 or more letters

Deezer ariana grande. Ariana Grande 10257966 fans Grammy winning, multi-platinum recording artist and international superstar, Ariana Grande, is the first artist to achieve the top three Billboard Hot 100 spots since The Beatles in 1964 with “7 Rings,” “Break Up With Your Girlfriend, I'm Bored,” and “Thank U, Next.”. Ariana Grande 10270075 fans Grammy winning, multi-platinum recording artist and international superstar, Ariana Grande, is the first artist to achieve the top three Billboard Hot 100 spots since The Beatles in 1964 with “7 Rings,” “Break Up With Your Girlfriend, I'm Bored,” and “Thank U, Next.”.

(n,m) require n - m

(a-z)w(1,7) match a UW NetID

* greedy versus *? lazy

* + and (n,) are greedy — match as much as possible

<.+> finds 1 big match in <b>bold</b>

*? +? and (n,)? are lazy — match as little as possible

<.+?> finds 2 matches in <b>bold</b>

comments — (?#comment)

(?#year)(19|20)dd embedded comment

(?x)(19|20)dd #year free spacing & EOL comment

(see modifiers)

scope — b B ^ $

b 'word' edge (next to non 'word' character)

bring word starts with 'ring', ex ringtone

ringb word ends with 'ring', ex spring

b9b match single digit 9, not 19, 91, 99, etc.

b(a-zA-Z)(6)b match 6-letter words

B NOT word edge

BringB match springs and wringer Body model sketch.

^ start of string $ end of string

^d*$ entire string must be digits

^(a-zA-Z)(4,20)$ string must have 4-20 letters

^(A-Z) string must begin with capital letter

(.!?'))$ string must end with terminal puncutation

Chrome we. Discover great apps, games, extensions and themes for Google Chrome.

groups — ( )

(in|out)put match input or output

d(5)(-d(4))? US zip code ('+ 4' optional)

Locate all PHP input variables:

$_(GET|POST|REQUEST|COOKIE|SESSION|SERVER)(.+)

NB: parser tries EACH alternative if match fails after group. Can lead to catastrophic backtracking.

back references — n

each ( ) creates a numbered 'back reference'

(to) (be) or not 1 2 match to be or not to be

((^s))1(2) match non-space, then same twice more aaa, ..

b(w+)s+1b match doubled words

non-capturing group — (?: ) prevent back reference

on(?:click|load) is faster than on(click|load)

use non-capturing or atomic groups when possible

atomic groups — (?>a|b) (no capture, no backtrack)

(?>red|green|blue)

faster than non-capturing

alternatives parsed left to right without return

(?>id|identity)b matches id, but not identity

'id' matches, but 'b' fails after atomic group, parser doesn't backtrack into group to retry 'identity'

If alternatives overlap, order longer to shorter.

lookahead — (?= ) (?! ) lookbehind — (?<= ) (?<! )

bw+?(?=ingb) match warbling, string, fishing, ..

b(?!w+ingb)w+b words NOT ending in 'ing'

Grep Regex Cheat Sheet

(?<=bpre).*?b match pretend, present, prefix, ..

bw(3)(?<!pre)w*?b words NOT starting with 'pre'

(lookbehind needs 3 chars, w(3), to compare w/'pre')

bw+(?<!ing)b match words NOT ending in 'ing'

(see LOOKAROUND notes below)

if-then-else — (?ifthen|else)

match 'Mr.' or 'Ms.' if word 'her' is later in string

M(?(?=.*?bherb)s|r). lookahead for word 'her'

(requires lookaround for IF condition)

modifiers — i s m x

ignore case, single-line, multi-line, free spacing

(?i)(a-z)*(?-i) ignore case ON / OFF

(?s).*(?-s) match multiple lines (causes . to match newline)

(?m)^.*;$(?-m)^ & $ match lines not whole string

(?x) #free-spacing mode, this EOL comment ignored

d(3) #3 digits (new line but same pattern)

-d(4) #literal hyphen, then 4 digits

(?-x) (?#free-spacing mode OFF)

/regex/ismx modify mode for entire string

A few examples:

(?s)<p(?(?=s) .*?)>(.*?)</p> span multiple lines

(?s)<p(?(?=s) .*?)>(.*?)</p> locate opening '<p'

(?s)<p(?(?=s) .*?)>(.*?)</p> create an if-then-else

(?s)<p(?(?=s) .*?)>(.*?)</p> lookahead for a whitespace character

(?s)<p(?(?=s) .*?)>(.*?)</p> if found, attempt lazy match of any characters until ..

(?s)<p(?(?=s) .*?)>(.*?)</p> closing angle brace

(?s)<p(?(?=s) .*?)>(.*?)</p> capture lazy match of all characters until ..

(?s)<p(?(?=s) .*?)>(.*?)</p> closing '</p>'

The lookahead prevents matches on PRE, PARAM, and PROGRESS tags by only allowing more characters in the opening tag if P is followed by whitespace. Otherwise, '>' must follow '<p'.

LOOKAROUND notes

(?= ) if you can find ahead

(?! ) if you can NOT find ahead

(?<= ) if you can find behind

(?<! ) if you can NOT find behind

convert Firstname Lastname to Lastname, Firstname (& visa versa)

Pattern below uses lookahead to capture everything up to a space, characters, and a newline. The 2nd capture group collects the characters between the space and the newline. This allows for any number of names/initials prior to lastname, provided lastname is at the end of the line.

Find: (.*)(?= .*n) (.*)n

Repl: 2, 1n — insert 2nd capture (lastname) in front of first capture (all preceding names/initials)

Reverse the conversion.

Find: (.*?), (.*?)n — group 1 gets everything up to ', ' — group 2 gets everything after ', '

Repl: 2 1n

lookaround groups are non-capturing

If you need to capture the characters that match the lookaround condition, you can insert a capture group inside the lookaround.

(?=(sometext)) the inner () captures the lookahead

This would NOT work: ((?=sometext)) Because lookaround groups are zero-width, the outer () capture nothing.

lookaround groups are zero-width

They establish a condition for a match, but are not part of it.

Compare these patterns: re?d vs r(?=e)d

re?d — match an 'r', an optional 'e', then 'd' — matches red or rd

r(?=e)d — match 'r' (IF FOLLOWED BY 'e') then see if 'd' comes after 'r'

Perl Regex Cheat Sheet Pdf

The lookahead seeks 'e' only for the sake of matching 'r'.

Because the lookahead condition is ZERO-width, the expression is logically impossible.

It requires the 2nd character to be both 'e' and 'd'.

For looking ahead, 'e' must follow 'r'.

For matching, 'd' must follow 'r'.

fixed-width lookbehind

Most regex engines depend on knowing the width of lookbehind patterns. Ex: (?<=h1) or (?<=w(4)) look behind for 'h1' or for 4 'word' characters.

This limits lookbehind patterns when matching HTML tags, since the width of tag names and their potential attributes can't be known in advance.

variable-width lookbehind

.NET and JGSoft support variable-width lookbehind patterns. Ex: (?<=w+) look behind for 1 or more word characters. The first few examples below rely on this ability.

Lookaround groups define the context for a match. Here, we're seeking .* ie., 0 or more characters. A positive lookbehind group (?<= . . . ) preceeds. A positive lookahead group (?= . . . ) follows. These set the boundaries of the match this way:

(?<=<(w+)>).*(?=</1>) look behind current location

(?<=<(w+)>).*(?=</1>) for < > surrounding ..

(?<=<(w+)>).*(?=</1>) one or more 'word' characters. The ( ) create a capture group to preserve the name of the presumed tag: DIV, H1, P, A, etc.

(?<=<(w+)>).*(?=</1>) match anything until

(?<=<(w+)>).*(?=</1>) looking ahead from the current character

(?<=<(w+)>).*(?=</1>) these characters surround

(?<=<(w+)>).*(?=</1>) the contents of the first capture group

In other words, advance along string until an opening HTML tag preceeds. Match chars until its closing HTML tag follows. The tags themselves are not matched, only the text between them.

Unix Regex Cheat Sheet Download

To span multiple lines, use the (?s) modifier. (?s)(?<=<cite>).*(?=</cite>) Match <cite> tag contents, regardless of line breaks.

As in example above, the first group (w+) captures the presumed tag name, then an optional space and other characters ?.*? allow for attributes before the closing >.

class='.*?bredb.*?' this new part looks for class=' and red and ' somewhere in the opening tag

b ensures 'red' is a single word

.*? allow for other characters on either side of 'red' so pattern matches class='red' and class='blue red green' etc.

Here, the first group captures only the tag name. The tag's potential attributes are outside the group.

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> set ignore case ON

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> find an opening tag by matching 1 letter after <

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> then match 0 or more letters or digits

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> make this tag a capture group

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> match 0 or more characters that aren't > — this allows attributes in opening tag

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> match the presumed end of the opening tag

(NB: This markup <a> would end the match early. Doesn't matter here. Subsequent < pulls match to closing tag. But if you attempted to match only the opening tag, it might be truncated in rare cases.)

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> lazy match of all of tag's contents

(?i)<((a-z)(a-z0-9)*)(^>)*>.*?</1> match the closing tag — 1 refers to first capture group

The IF condition can be set by a backreference (as here) or by a lookaround group.

(()?d(3) optional group ( )? matches '(' prior to 3-digit area code d(3) — group creates back reference #1

(?(1)) ?|(-/ .)) (1) refers to group 1, so if '(' exists, match ')' followed by optional space, else match one of these: '- / . '

d(3)(- .)d(4) rest of phone number

Unix Regex Cheat Sheet Example

For a quick overview: http://www.codeproject.com/KB/dotnet/regextutorial.aspx.

For a good tutorial: http://www.regular-expressions.info.

We would like to show you a description here but the site won’t allow us. Walmart insurance copay.

[afgprogrammer]

PHP Conditional Statements: Very often when you write code, you want to perform different actions for different conditions. You can use conditional statements in your code to do this. In PHP we have the following conditional statements: if statement - executes some code if one condition is true if...else statement - executes some code if a condition is true and another code if that condition is false if...elseif...else statement - executes different codes for more than two conditions Ternary Operators In addition to all this conditional statements, PHP provides a shorthand way of writing if…else, called Ternary Operators. The statement uses a question mark (?) and a colon (:) and takes three operands: a condition to check, a result for TRUE and a result for FALSE. #php #code #coding #phpdevelooer #developer #afgprogrammer #codesnippet #phpprogramming https://www.instagram.com/p/CLRhNqpjQyn/?igshid=msos8smu9fd3

[npmjs]

My First npm Publish

My first npm publish was unusual. npm didn't exist at the time, so that presented a bit of a challenge.

This is the story of helping to inventing a universe so that I could make an apple pie from scratch.

SSJS

Back in 2009, I was working at Yahoo! as a Front-End Engineer. That meant that I wrote a lot of PHP and JavaScript. I had just finished a project where we had front-end components generated on the back-end and shipped to the client based on some data being parsed into a template, and then later on, on the front-end, do the same work in JavaScript with the same templates and data services.

These days, that'd be called "fast boot" or "isometric templates" or something clever, but back in those dark days, it required tediously maintaining two implementations of a view layer, one in PHP and the other in JavaScript. Maintaining the same thing in two languages was downright awful.

"Well", I figured, "JavaScript is a language, and we can control what's on the server, why not just run JavaScript on the server?"

The state of the art in server-side JavaScript (SSJS) was Rhino on the JVM. The problem was, unless you compiled your JavaScript into JVM bytecode using arcane special magicks, it was godawful slow. I started messing around with V8 and SpiderMonkey, thinking "I want something like PHP, but JavaScript".

The SSJS community at that time was a very different place than the Node.js of today. There were dozens of projects, any one of which could've seemed like it would be the breakout hit. SpiderApe and v8-juice were trying to make it easier to embed spidermonkey and v8, and add a standard library to each. v8cgi (renamed to TeaJS) provided a CGI binding to use v8 in Apache2. I started messing around with K7, which provided a bunch of macros for using V8 in various contexts, and Narwhal, which was the only one of these that seemed to be delivering a fully thought-out platform for making programs. There was also Helma and RingoJS, and probably a bunch of others I'm forgetting.

A few years ago, we used to joke that every Node.js dev had their own test framework and argument parser. Well, in 2009, every server-side JavaScript developer had their own SSJS platform.

The contributors to all of these platforms got together in a mailing list and tried to form some kind of standard for server-side JavaScript programming. Front-end JavaScript has the DOM, so we thought, and right now, writing server-side JavaScript suffers from a dearth of portability. What we need is a standards body, clearly! This was initially called "ServerJS", but then expanded its scope to CommonJS.

The first proper "module" I wrote in JavaScript was a port of a url parser I wrote for YUI. I landed it in Narwhal. There was no userland, really. Just lots of little cores.

Some time later, in August of 2009, I gave a tech talk about SSJS and demonstrated using Narwhal and Jack, a Rack-like thing built on top of Narwhal, using the JSGI protocol.

After the talk, one of the people in the audience asked if I'd ever tried out Node.js. As it turned out, I had, but like so many SSJS platforms:

It had a single developer working on it, and no other contributors or community.

The documentation was extremely sparse

It failed to build on my mac laptop.

Ergo: Not a thing.

"I dunno," he said. "Maybe try it again. It's pretty nifty."

He insisted that it was fast, and I was like, "Meh. JVM is fine."

Node.js

I checked the website again, and they'd added a "Community" section. Also, the docs still sucked, but it was version 0.0.6 now, which was like, 4 more than it was the first time I'd checked, so whoever this Ryan guy was, he was at least working hard on the thing.

It compiled successfully, and I was hooked! It started up so fast compared to Rhino! And it had tests that ran when I did make test, and they passed!

3 important lessons for OSS success:

Docs and tests matter.

At least have a link to a mailing list or something. (Remember: this was before GitHub connected us all with Issues.)

It has to build and be fast.

I gradually stopped paying much attention to CommonJS, and instead just threw my efforts at Node. I hung out on the mailing list and in IRC during all my free time.

The problem with Node back then was that even though a growing number of people were all writing really interesting programs, it was hard to share them. So, I wrote this thing, which was a port of a bash script I was using to play with people's code.

The Registry

Technically that wasn't "publishing" though. In order to actually publish to npm there had to be an npm registry. Today, that registry is a webservice at https://registry.npmjs.org/, run by npm, Inc.. The first registry was a git repo called "npm-data". I collected up the handful of modules that'd been shared from on the mailing list and in the Node.js wiki page, and made a JSON file with links to them.

One principle of package management that I felt was really important was that no one person should be the bottleneck in community growth. Especially if that person is me. Because I really hate that crap.

I don't mind working really hard on lots of challenging stuff, but if I have to do some simple task over and over again, especially if other people are depending on me to do it, it's like torture to me. The prospect of being in someone's critical path for deploying their module was just... ugh. Gross.

I needed a web service type thing that would let people publish packages and then could download those packages and install them.

I got to talking to Mikeal Rogers, who worked at Couch.IO. He built the first npm registry CouchApp, and got it functional.

Fun fact! For a little while, anyone could publish any package, and we relied on the honor system to keep anyone from clobbering anyone else's name. It was an ok system for a short while, since there were only about 4 or 5 people in the world who knew this thing existed, but we got an authentication and authorization system set up before anyone could take advantage of it.

By that time, I'd quit my job at Yahoo! and was taking a sabatical. If you can afford it, I highly recommend saving up a little nest egg and taking a few months off to see what comes out of you. Muses can be fickle, and tend to call when least expected.

I know what you're thinking...

You're thinking that the culmination of this story is that I published npm to npm and that was my first npm publish, and it'll be super meta and awesome like that. It'd be a beautiful punchline.

Real life is sloppy sometimes.

I knew that I wanted npm to be able to accept abbreviated versions of commands, so that npm inst would do the same thing as npm install. (To this day, the friendly CLI shorthands are some of npm's most beloved features.)

The first thing I published to npm was abbrev. I'd written it already, mostly as a sort of coding crossword puzzle some... Saturday? Wednesday? All the days were pretty identical during those two lazy/exhausting months of funemployment.

Since abbrev was only one module, no build command, it was really easy to publish and install repeatedly. Ever since then, it's always been one of my go-to testing modules to make sure things are working properly. Not only was it my first npm publish, it was the first npm publish, and it was published probably dozens or hundreds of times to http://localhost:5984/ while I was working on npm. So, of course, when I had a registry running on my little DreamHost instance, abbrev was the first thing I published to it.

The really wacky part: despite it being the first thing I'd published with npm, I didn't actually use abbrev in npm until 5 months later. That whole time I kept trying to figure out how to have proper dependencies in the thing that installed dependencies. Eventually, I gave up and threw it in a utils folder.

Looking back over abbrev now, it's amazing to me how little it's changed. Most of the code is still that initial implementation from May 2010.

The moral of the story is that you don't know how it's going to end.

[mbaljeetsingh]

Moving from NodeJS to Go

The approach of this article is this:

You are a seasoned NodeJS developer, and are looking to learn a new language, but you don't want to go deep, just see how things compare with your current expertise, and then make a final decision.

Chances are, you were initially a PHP developer, then you found your way into NodeJS and now you feel like you want to expand your expertise. Of course I might be wrong, but in this article we are going to look at some common patterns when working with NodeJS and how they compare in Go.

Since this is a NodeJS to Go comparison, we're going to focus on language constructs and servers. We'll break it down like this:

The most common reasons to learn Go include the following:

We see that Go has only 25 keywords, and this can give you a clue on how simple it is to learn the language. We'll also be looking at the common language patterns, and we'll see how cleaner and easier it is to do some common tasks as compared to other languages. The standard library that comes with Go also has a lot of built in functionality, that you will find yourself rarely relying on other external libraries. Go code will not compile if you have unused variables or syntax errors.

Here's an example with the net/http package that we'll use later. You can see examples are provided, and there are even tabs for the source code files. Sweet!

Is Go Better Than JavaScript ?. No, I don't think so, nor do I think JavaScript is better. The idea is to use the right tool for the job, and sometimes, one tool is better than another one, or one developer is better in one tool over another. So learn what you can, and choose the right thing that you are sure will get the job done for you.

We'll look at a few language constructs that we are used to.

Here's a hello world program in NodeJS

console.log('Hello World');

Running this will produce Hello World in the terminal.

node app.js

Here's an equivalent hello world program in Go

package main import "fmt" func main() { fmt.Println("Hello World") }

What we'll notice first, is that Go follows a certain structure which involves: This code can be run by typing in the following, or see it in GoPlay Space.

go run main.go

where main.go is the name of the file.

JavaScript is dynamically typed, which means you do not have to specify types when defining variables, and the variables can change their types as you program along.

That being said, JavaScript has the following types:

To define variables in JavaScript(NodeJS) we'd write this:

const num = 3; let flt = 2.34; let a = true; let b = false; var name = 'Scotch';

Go however, is statically typed, which means we have to define the types before hand, or assign them and let them be inferred. Here's a comprehensive list of Go Types.

An equivalent of the above JavaScript definitions in Go is

package main const num = 3 func main() { var flt float64 = 2.34 var name string = "Scotch" a, b := 2.34 // shorthand declaration syntax }

Assigning initial values in Go is done by with the var keyword, a variable name, and a type. Additionally and more commonly the := shorthand syntax can be used. When declaring variables with := , they are automatically assigned the correct type. The shorthand declaration syntax can only be used within a function. Finally, you can assign multiple values in one line like we have done in a, b := true, false. This will assign both a and b to the right hand values respectively.

Here is an array of strings in JavaScript

const names = ['Scotch', 'IO'];

While Go has arrays, what we typically refer to arrays in JavaScript are referred to as slices in Go. Here's an example of a slice in Go:

package main func main() { names := []string{"Scotch", "IO"} }

As an example, we'll write a small program that returns the substring of a string at index 10. So a sentence like Luke, I'm not your father will end up being Luke, I'm

JavaScript

const sentence = '`Look, I\'m not your Father';` console.log(sentence.substr(0,10));

Go

package main import "fmt" func main() { sentence := "Look, I'm not your Father" fmt.Println(sentence[:10]) }

You can run the app in Goplay Space

Conditional statements include if else and switch statements. Here's an example in NodeJS.

const age = 10; if (age > 10) { console.log('You are old'); } console.log('you are young'); const gender = 'female'; switch(gender) { case 'female': console.log('your name is tonie'); break; case 'male': console.log('your name is tony'); break;; default: /// }

Here's a equivalent Go

package main import "fmt" func main() { age := 10 if age > 10 { fmt.Println("You are old") } fmt.Println("You are young") gender := "female" switch gender { case "female": fmt.Println("Your name is tonie ") case "male": fmt.Println("Your name is tony") default: /// } }

You can run the app in GoPlay Space.

You'll notice the conditionals are a bit cleaner in Golang, with less brackets.

JavaScript has 3 loops: for loop, while loop, and a do while loop. Here's a for loop example.

// normal for loop for i = 0; i < 10; i++ { console.log(i); } // key, value loop for (var key in p) { if (p.hasOwnProperty(key)) { console.log(key + ' -> ' + p[key]); } } // another key value loop Object.keys(obj).forEach(function(key) { console.log(key, obj[key]); }) // there's also a `for...of`

Go has only one type of loop, and it's the for loop. Don't let that deceive you though as the for loop in Go is very versatile and can emulate almost any type of loop. Let's look at a simple example:

package main import ( "fmt" ) func main() { for i := 0; i < 10; i++ { fmt.Println(i) } // key value pairs kvs := map[string]string{ "name": "Scotch", "website": "https://scotch.io", } for key, value := range kvs { fmt.Println(key, value) } }

You can run the app in GoPlay Space.

Now that we know a little about the similarities and differences in language constructs, we can have a look at servers. Since we are coming from NodeJS it's likely that we're building a server, that returns JSON for instance.

In NodeJS, chances are while writing a server, you are using Express as the base library for your server. It's the most common, comes with a router and is the most battle tested. Here's a NodeJS server.

const express = require('express'); const app = express(); app.get('/', (req, res) => { res.send('Hello from Express!'); }) app.listen(3000, err => { if (err) { return console.log('something bad happened', err); } console.log(`server is listening on 3000`); })

Unlike JavaScript, the Go standard library provides everything we need to get a server up and running without any external dependencies. The net/http package provides most of this functionality. When building larger applications, expanding on the base net/http package with third-party packages is common, and one popular library that provides greatly expanded functionality is the Gorilla Web Toolkit.

Here's an equivalent Server in Go without any external library.

package main import ( "net/http" ) func Hello(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello World")) } func main() { http.HandleFunc("/", Hello) if err := http.ListenAndServe(":8080", nil); err != nil { panic(err) } }

Things are starting to get interesting now.

if err != nil { // do something here // return err or panic panic(err) }

You can test this by running go run main.go, assuming your file was named main.go

Now, let's introduce a router library, because, if we don't, we'll have a lot of this in our code.

if req.Method == "POST" { // do this }

To get packages with golang, you usually use a go get <github-link>. To get Gorilla Mux from the Gorilla Web Toolkit we mentioned earlier, we would write the following in our terminal:

go get -u github.com/gorilla/mux

Then we are able to do this. I pulled this directly from Gorilla mux documentation.

package main import ( "fmt" "net/http" "github.com/gorilla/mux" ) func main() { r := mux.NewRouter() r.HandleFunc("/", HomeHandler) r.HandleFunc("/products", ProductsHandler) r.HandleFunc("/articles", ArticlesHandler) // details r.HandleFunc("/products/{key}", ProductHandler) r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler) r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler) http.Handle("/", r) } // example handler func ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) w.WriteHeader(http.StatusOK) fmt.Fprintf(w, "Category: %v\n", vars["category"]) }

We see that the same way express accepts patterns, Gorilla mux allows us to use the same patterns. It can get a little complicated than what I've described, but I hope you get the idea.

Gorilla mux also comes with helper functions that npm's body parser helps us achieve. Go purist can however claim that these function can easily be written.

Middleware are a great part of NodeJS servers.

They are functions that sit somewhere, and are run before the actual request is run. In NodeJS, this is a simple snippet for a middleware that retrieves a secret from the env and uses it to authenticate a user. When reading variables from NodeJS, dotenv is commonly used.

const express = require('express'); const app = express(); // add server_name middleware function authenticate((req, res, next) => { const secret = process.ENV.SECRET; if (secret == "") { return res.send("secret not found"); } if (!isAuthenticated(req, secret)) { return res.send("invalid authentication"); } return next(); }) app.get('/', authenticate, (req, res) => { res.send('Hello from Express!'); }) app.listen(3000, err => { if (err) { return console.log('something bad happened', err); } console.log(`server is listening on 3000`); })

Go takes a similar approach. Since all a middleware does is take in a request do, something with it and decide whether the request should proceed.

package main import ( "net/http" "os" ) // our sample authenticate middleware func Authenticate(next http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r _http.Request) { secret := os.Getenv('SECRET') if len(secret) == 0 { w.Write(_[_]byte("secret not found") return } if !isAuthenticated(r, secret) { w.Write(_[_]byte("invalid authentication")) return } next.ServeHTTP(w, r) } func Hello(w http.ResponseWriter, r _http.Request) { w.Write([]byte("Hello World")) } func main() { http.HandleFunc("/", Authenticate(Hello)) // call the middeware by wrapping if err := http.ListenAndServe(":8080", nil); err != nil { panic(err) } }

If you are a seasoned JavaScript developer, you've probably noticed functions are first class citizens in Go too.

We've just written a function that takes in a [http.HandlerFunc](https://golang.org/pkg/net/http/#HandlerFunc) which is a function type, and the function structure is type HandlerFunc func(ResponseWriter, *Request), just like the Handler we wrote.

The advantage is that the http.HandlerFunc type has a function ServeHTTP which takes in the response and the request pointer we passed, and executes the handle call.

Some people call this approach wrapping functions, but this is the general idea. Again, you can easily write your own middlewares, but there are a couple of libraries out there to help you like http://www.gorillatoolkit.org/pkg/handlers and https://github.com/urfave/negroni.

Most of the time, our servers usually depend on an external API to get some data it needs. Let's say for example we are getting users from Github.

This is the approach you would take in a NodeJS app.

You'll first install a http request module, such as axios. npm install axios

const axios = require('axios'); const url = 'https://api.github.com/users'; axios.get(url).then(res => { // do something with the response }).catch(err => { // do something with the error })

This piece of code can either be in your service, or anywhere you like.

In Go, however, we do not need any external dependencies, and the net/http package can help us with this scenario.

package main import ( "fmt" "io/ioutil" "log" "net/http" ) func main() { URL := "https://api.github.com/users" res, err := http.Get(URL) if err != nil { log.Println(err) } defer res.Body.Close() // for garbage collection responseBodyBytes, err := ioutil.ReadAll(res.Body) if err != nil { log.Println(err) } fmt.Println(string(responseBodyBytes)) }

We use http.Get to make requests, and check errors. The response is usually in bytes, and we have to read it first, then convert it to string with strinb([]bytes).

You can add this to a main.go file and run go run main.go.

This code can also easily be converted to a func, and called repeatedly when needed.

NodeJS has various npm modules to help in database connections depending on the databases that you are using.

These libraries most of the time come with their own methods, that try to make it easier for you to work with them, and some even offer ORM like features.

Go however takes a different approach. The standard library provides an interface for working with databases called https://golang.org/pkg/database/sql/ which RDBMS package authors can use to implement drivers for various databases. Authors following the standard interface ensure greater interoperability for their packages.

Common database driver packages include: But to save you a lot of hustle, especially with SQL databases, https://github.com/jmoiron/sqlx will boost your productivity. Not to be left out of the ORM game either, the Go community has written many excellent ORMs such as https://github.com/jinzhu/gorm.

Go's files must be written within packages, and this usually affects your file structure.

In JavaScript, you'll see a lot of require statements at the beginning of files, while in Golang, the first line is always a package name, which will then be used as an import path in a file where it's required import package_path/package_name

I hope you've gotten a gist of what it's like to write Go, and you'd like to get into action. Golang is really praised for it's concurrency and performance, and if you are building a large application, this would be a preferred choice.

Here are some other cool stuff I did not cover, but are worth mentioning.

I've been following this transitional journey for a while now, and would glady answer any questions you may have. Just leave a comment.

Happy Go-ing! ;-)

via Scotch https://ift.tt/2yaUGB6