In Rust, there are 2 ways to sort a vector.
Using sort Method
The sort(&mut self) method sorts the slice. This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case. For example,
fn main() {
let mut v = [3, -5, 2, 6, 1];
v.sort();
println!("{:?}", v);
let mut s = ["b", "d", "c", "a"];
s.sort();
println!("{:?}", s);
}
[-5, 1, 2, 3, 6]
["a", "b", "c", "d"]
Using sort_by Method
The sort_by(&mut self, compare: F) method sorts the slice with a comparator function. The comparator function must define a total ordering for the elements in the slice. If the ordering is not total, the order of the elements is unspecified. For example,
fn main() {
let mut v = [5, 4, 1, 3, 2];
v.sort_by(|a, b| a.cmp(b));
println!("{:?}", v);
let mut s = ["b", "d", "c", "a"];
s.sort_by(|a, b| b.cmp(a));
println!("{:?}", s);
}
[1, 2, 3, 4, 5]
["d", "c", "b", "a"]
In Golang, there are 2 ways to check if a slice contains an element.
Using contains Function
The following example should cover whatever you are trying to do:
package main
import "fmt"
func Contains[E comparable](s []E, v E) bool {
for _, vs := range s {
if vs == v {
return true
}
}
return false
}
func main() {
s := []string{"Gopher", "Alice", "Bob"}
fmt.Println(Contains(s, "Bob"))
fmt.Println(Contains(s, "bob"))
}
true
false
Using slices.Contains Function
Starting with Go 1.18, you can use the slices package – specifically the generic Contains function:
package main
import (
"fmt"
"golang.org/x/exp/slices"
)
func main() {
s := []string{"Gopher", "Alice", "Bob"}
b := slices.Contains(s, "Bob")
fmt.Println(b)
b = slices.Contains(s, "bob")
fmt.Println(b)
}
true
false
In Golang, using the sort.Slice function is the easiest way to sort a slice
Using Slice Function
You simply pass an anonymous function to the sort.Slice function:
package main
import (
"fmt"
"sort"
)
func main() {
s := []string{"Houston", "Atlanta", "Boston"}
sort.Slice(s, func(i, j int) bool {
return s[i] < s[j]
})
fmt.Println(s)
a := []int{6, 4, 2}
sort.Slice(a, func(i, j int) bool {
return a[i] < a[j]
})
fmt.Println(a)
}
[Atlanta Boston Houston]
[2 4 6]
Slice sorts the slice x given the provided less function. It panics if x is not a slice.
See the following example:
package main
import (
"fmt"
"sort"
)
func main() {
people := []struct {
Name string
Age int
}{
{"Gopher", 7},
{"Alice", 55},
{"Vera", 24},
{"Bob", 75},
}
sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("By name:", people)
sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("By age:", people)
}
By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]
By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]
In Golang, there are 2 ways to check string is in json format.
Using Unmarshal Function
The following example should cover whatever you are trying to do:
package main
import (
"encoding/json"
"fmt"
)
func isJson(s string) bool {
var js json.RawMessage
return json.Unmarshal([]byte(s), &js) == nil
}
func isQuotedJson(s string) bool {
var js map[string]interface{}
return json.Unmarshal([]byte(s), &js) == nil
}
func main() {
s := `{"key":"value"}`
b := isJson(s)
fmt.Println(b)
b = isQuotedJson(s)
fmt.Println(b)
}
true
true
Using Standard Library Function
Standard encoding/json library contains json.Valid function starting from go 1.9. This function may be used for checking whether the provided string is a valid json:
package main
import (
"encoding/json"
"fmt"
)
func main() {
s := `{"key":"value"}`
b := json.Valid([]byte(s))
fmt.Println(b)
}
true
In Golang, there are 2 ways to duplicate slices.
Using append Function
You could write one simple statement to make a shallow copy of a slice.
The following example should cover whatever you are trying to do:
package main
import "fmt"
type T int
func main() {
a := []T{1, 2}
b := append([]T(nil), a...)
fmt.Println(a, b)
b[1] = 4
fmt.Println(a, b)
}
[1 2] [1 2]
[1 2] [1 4]
Using copy Function
See the following example:
package main
import "fmt"
type T int
func main() {
a := []T{1, 2}
b := make([]T, len(a))
copy(b, a)
fmt.Println(a, b)
b[1] = 4
fmt.Println(a, b)
}
[1 2] [1 2]
[1 2] [1 4]
In Python, using the __file__ is the easiest way to get name of current script.
Using Module Attributes
You can use __file__ to get the name of the current file. When used in the main module, this is the name of the script that was originally invoked.
See the following example:
#!/usr/bin/python3
# Import module
import os
print(__file__)
# omit the directory part
print(os.path.basename(__file__))
/home/python/demo.py
demo.py
In Python, there are 2 ways to determine whether a given integer is between two other integers.
Using Comparisons
Unlike C, all comparison operations in Python have the same priority, which is lower than that of any arithmetic, shifting or bitwise operation. Also unlike C, expressions like a
See the following example:
#!/usr/bin/python3
i = 20
if 10 < i < 40:
print(True)
True
Using range
For example,
#!/usr/bin/python3
i = 10
r = range(10, 30)
if i in range(10, 30):
print(True)
print(30 in r)
print(20 in r)
True
False
True
In Python, there are 2 ways to delete a character from a string.
Using replace Method
The str.replace(old, new[, count]) method returns a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.
See the following example:
#!/usr/bin/python3
s = "Hello"
s = s.replace("l", "")
print(s)
Heo
Using Slice Syntax
Specify the start index and the end index, separated by a colon, to return a part of the string.
For example,
#!/usr/bin/python3
# remove character
def remove(str, rep):
i = str.find(rep)
if i == -1:
return str
str = str[:i]+str[i+1:]
return remove(str, rep)
s = "Hello"
s = remove(s, 'l')
print(s)
Heo
In Python, there are 2 ways to make a list of alphabet characters.
Using string Module
The string.ascii_lowercase is a pre-initialized string used as string constant. In Python, string ascii_lowercase will give the lowercase letters ‘abcdefghijklmnopqrstuvwxyz’.
See the following example:
#!/usr/bin/python3
# Import module
import string
# string.ascii_lowercase
# string.ascii_uppercase
# string.ascii_letters
ls = list(string.ascii_lowercase)
print(ls)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
Using range Function
The range(start, stop[, step]) function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and stops before a specified number.
For example,
#!/usr/bin/python3
ls = list(map(chr, range(97, 123)))
print(ls)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
String module features:
Object type:
##### string.whitespace
\t\n\r\v\f
##### string.ascii_letters
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
##### string.ascii_lowercase
abcdefghijklmnopqrstuvwxyz
##### string.ascii_uppercase
ABCDEFGHIJKLMNOPQRSTUVWXYZ
##### string.digits
0123456789
##### string.hexdigits
0123456789abcdefABCDEF
##### string.octdigits
01234567
##### string.printable
digits + ascii_letters + punctuation + whitespace
##### string.punctuation
!"#$%&\'()*+,-./:;
[email protected][\\]^_`{|}~
In Golang, using the Unmarshal JSON function is the easiest way to Marshal / Unmarshal json with a custom type attribute.
JSON (JavaScript Object Notation) is a lightweight data-interchange format.
Using UnmarshalJSON Function
Example on custom UnmarshalJSON and MarshalJSON.
The following example should cover whatever you are trying to do:
package main
import (
"encoding/json"
"fmt"
"strconv"
"time"
)
type CustTimeUinx int64
func (t *CustTimeUinx) UnmarshalJSON(b []byte) error {
s, _ := strconv.Unquote(string(b))
uinx := int64(0)
if len(s) != 0 {
d, _ := time.Parse("2006-01-02 15:04:05", s)
uinx = d.Unix()
}
*t = CustTimeUinx(uinx)
return nil
}
func (t *CustTimeUinx) MarshalJSON() ([]byte, error) {
uinx := int64(*t)
quoted := strconv.Quote(time.Unix(uinx, 0).Format("2006-01-02 15:04:05"))
return []byte(quoted), nil
}
type TestItem struct {
Curr CustTimeUinx `json:"Curr"`
}
func main() {
// Unmarshal Json
s := `{"curr":"2022-06-26 10:00:00", "age":10}`
var data TestItem
json.Unmarshal([]byte(s), &data)
b, _ := json.MarshalIndent(data, "", " ")
fmt.Printf("%s\n", b)
// Marshal Json
d := TestItem{
Curr: CustTimeUinx(1656237600),
}
js, _ := json.Marshal(&d)
fmt.Printf("%s\n", js)
}
{
"Curr": 1656237600
}
{"Curr":"2022-06-26 18:00:00"}
In Python, using the uniform function is the easiest way to get a random number between a float range.
Using uniform Method
The random.uniform(a, b) method returns a random floating point number N such that a
See the following example:
#!/usr/bin/python3
# Import module
import random
a = random.uniform(1.3, 2.4)
print(a)
1.654179463181758
2.044145546151235
The end-point value b may or may not be included in the range depending on floating-point rounding in the equation a + (b-a) * random().
if you want generate a random float with N digits to the right of point, you can make this:
#!/usr/bin/python3
# Import module
import random
a = random.uniform(1.3, 2.4)
b = round(a, 4)
print(b)
2.2657
In Python, there are 2 ways to extract all the numbers contained in a string.
Using List Comprehension
List comprehensions provide a concise way to create lists.
If you only want to extract only positive integers, try the following:
#!/usr/bin/python3
s = "The 2.0L 2023 AMG C 63 Wagon"
l = [int(c) for c in s.split() if c.isdigit()]
print(l)
[2023, 63]
The other solution is:
#!/usr/bin/python3
s = "The2.0L2023AMGC63Wagon"
s = ''.join((ch if ch in '0123456789.' else ' ') for ch in s)
l = [float(i) for i in s.split()]
print(l)
[2.0, 2023.0, 63.0]
Using Regexp
A more robust version would be:
#!/usr/bin/python3
# Import module
import re
s = "The2.0L2023AM.GC63Wagon"
l = re.findall(r'[-+]?(?:\d*\.\d+|\d+)', s)
print(l)
[2023, 63]
To catch different patterns it is helpful to query with different patterns.
different number patterns'[\d]+[.,\d]+'(finds commas) 12,300 or 12,300.00'[\d]*[.][\d]+'(finds floats) 0.123 or .123'[\d]+'(finds integers) 123'[\d]+[.,\d]+|[\d]*[.][\d]+|[\d]+'(finds integers) 123'[\d]+'Combine with pipe ( | ) into one pattern with multiple or conditionals.
In Golang, using the crypto/aes package is the easiest way to encrypt a string using AES CBC.
Ehrsam, Meyer, Smith and Tuchman invented the cipher block chaining (CBC) mode of operation in 1976. In CBC mode, each block of plaintext is XORed with the previous ciphertext block before being encrypted.
Using NewCBCEncrypter Function
The cipher.NewCBCEncrypter(cipher Block) function returns returns a BlockMode which encrypts in cipher block chaining mode, using the given Block. The length of iv must be the same as the Block's block size.
The following example should cover whatever you are trying to do:
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"io"
)
func PKCS7Padding(ciphertext []byte, blockSize, after int) []byte {
padding := (blockSize - len(ciphertext)%blockSize)
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
func PKCS7Unpad(b []byte, blocksize int) ([]byte, error) {
if blocksize <= 0 {
return nil, errors.New("invalid blocksize")
}
if len(b) == 0 {
return nil, errors.New("unpad error")
}
if len(b)%blocksize != 0 {
return nil, errors.New("unpad error")
}
c := b[len(b)-1]
n := int(c)
if n == 0 || n > len(b) {
return nil, errors.New("unpad error")
}
for i := 0; i < n; i++ {
if b[len(b)-n+i] != c {
return nil, errors.New("unpad error")
}
}
return b[:len(b)-n], nil
}
func AesCBCEncrypt(key string, text string) (string, error) {
plaintext := PKCS7Padding([]byte(text), aes.BlockSize, len(text))
// CBC mode works on blocks so plaintexts may need to be padded to the
// next whole block.
if len(plaintext)%aes.BlockSize != 0 {
return "", errors.New("plaintext is not a multiple of the block size")
}
block, err := aes.NewCipher([]byte(key))
if err != nil {
return "", err
}
// The IV needs to be unique, but not secure. Therefore it's common to
// include it at the beginning of the ciphertext.
ciphertext := make([]byte, aes.BlockSize+len(plaintext))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
panic(err)
}
mode := cipher.NewCBCEncrypter(block, iv)
mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)
// It's important to remember that ciphertexts must be authenticated
// (i.e. by using crypto/hmac) as well as being encrypted in order to
// be secure.
return hex.EncodeToString(ciphertext), nil
}
func AesCBCDecrypt(key string, text string) (string, error) {
ciphertext, err := hex.DecodeString(text)
if err != nil {
return "", err
}
block, err := aes.NewCipher([]byte(key))
if err != nil {
return "", err
}
if len(ciphertext) < aes.BlockSize {
return "", errors.New("ciphertext too short")
}
iv := ciphertext[:aes.BlockSize]
ciphertext = ciphertext[aes.BlockSize:]
// CBC mode always works in whole blocks.
if len(ciphertext)%aes.BlockSize != 0 {
return "", errors.New("ciphertext is not a multiple of the block size")
}
mode := cipher.NewCBCDecrypter(block, iv)
mode.CryptBlocks(ciphertext, ciphertext)
// If the original plaintext lengths are not a multiple of the block
// size, padding would have to be added when encrypting, which would be
// removed at this point.
ciphertext, _ = PKCS7Unpad(ciphertext, aes.BlockSize)
return string(ciphertext[:]), nil
}
func main() {
s := "Hello"
key := "zb0SLh88rdSHswjcgcC6949ZUuopGXTt"
ciphertext, _ := AesCBCEncrypt(key, s)
fmt.Println(ciphertext)
plaintext, _ := AesCBCDecrypt(key, ciphertext)
fmt.Printf("Decrypt:: %s\n", plaintext)
}
22fb92560a7a1e7a9ba881943d5e078c517343133049b8ff4b5492a7b2276b3e
Decrypt:: Hello
In Golang, using the crypto/aes package is the easiest way to encrypt a string using AES GCM 256.
In cryptography, Galois/Counter Mode (GCM) is a mode of operation for symmetric-key cryptographic block ciphers which is widely adopted for its performance.
Using NewGCM Function
The cipher.NewGCM(cipher Block) function returns the given 128-bit, block cipher wrapped in Galois Counter Mode
with the standard nonce length.
The following example should cover whatever you are trying to do:
package main
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"fmt"
"io"
)
func AesGCMIv() ([]byte, error) {
// Never use more than 2^32 random nonces with a given key because of the risk of a repeat.
nonce := make([]byte, 12)
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return nil, err
}
return nonce, nil
}
func AesGCMEncrypt(key string, text string) (string, error) {
// When decoded the key should be 16 bytes (AES-128) or 32 (AES-256).
block, err := aes.NewCipher([]byte(key))
if err != nil {
return "", err
}
plaintext := []byte(text)
nonce, err := AesGCMIv()
if err != nil {
return "", err
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
ciphertext := aesgcm.Seal(nonce, nonce, plaintext, nil)
return fmt.Sprintf("%x", ciphertext), nil
}
func AesGCMDecrypt(key string, text string) (string, error) {
// When decoded the key should be 16 bytes (AES-128) or 32 (AES-256).
block, err := aes.NewCipher([]byte(key))
if err != nil {
return "", err
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
in, _ := hex.DecodeString(text)
ns := aesgcm.NonceSize()
nonce, ciphertext := in[:ns], in[ns:]
plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
return "", err
}
return string(plaintext[:]), nil
}
func main() {
s := "Hello"
key := "zb0SLh88rdSHswjcgcC6949ZUuopGXTt"
ciphertext, _ := AesGCMEncrypt(key, s)
fmt.Println(ciphertext)
plaintext, _ := AesGCMDecrypt(key, ciphertext)
fmt.Printf("Decrypt:: %s\n", plaintext)
}
0680f8fef173fd969bb073d614e7059b62147b0e8eb6a7fdbe3040a8cd3a0d05c5
Decrypt:: Hello
In Golang, using the crypto/hmac library is the easiest way to generate a SHA256 HMAC Hash from a string.
In cryptography, an HMAC (hash-based message authentication code) is a specific type of message authentication code (MAC) involving a cryptographic hash function and a secret cryptographic key.
Using hmac Package
The hmac.New() function returns a new HMAC hash using the given hash.Hash type and key.
The following example should cover whatever you are trying to do:
package main
import (
"crypto/hmac"
"crypto/sha256"
"fmt"
)
func main() {
s := "Hello"
key := "FDJ1mnhuzjFjTdwhq7DtZG2Cq9kuuEZCG"
h := hmac.New(sha256.New, []byte(key))
h.Write([]byte(s))
fmt.Printf("%x\n", h.Sum(nil))
fmt.Printf("%x\n", sha256.Sum256([]byte(s)))
}
b5352927e7a57a6485fa4afa7452b3817abe47d07c8aa2511bdcb9a43ac0f224
185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969
Generating a MD5 HMAC Hash
For example,
package main
import (
"crypto/hmac"
"crypto/md5"
"fmt"
)
func main() {
s := "Hello"
key := "FDJ1mnhuzjFjTdwhq7DtZG2Cq9kuuEZCG"
h := hmac.New(md5.New, []byte(key))
h.Write([]byte(s))
fmt.Printf("%x\n", h.Sum(nil))
}
ed1d2af782f2fa171867e4e810bf9a3d
block length:
Hash function H
b, bytes
L, bytes
MD5
64
16
SHA-1
64
20
SHA-224
64
28
SHA-256
64
32
SHA-512/224
128
28
SHA-512/256
128
32
SHA-384
128
48
SHA-512
128
64
SHA3-224
144
28
SHA3-256
136
32
SHA3-384
104
48
SHA3-512
72
64
out = H( in )L = length( out )b = H's internal block length
In Golang, using the Sum256 function is the easiest way to get a SHA256 hash from a string. Go implements several hash functions in various crypto/* packages.
Using Sum256 Function
The sha256.Sum256() function returns the SHA256 checksum of the data.
The following example should cover whatever you are trying to do:
package main
import (
"crypto/sha256"
"encoding/hex"
"fmt"
)
func main() {
s := "Hello"
sum := sha256.Sum256([]byte(s))
fmt.Printf("%x\n", sum)
fmt.Println(hex.EncodeToString(sum[:]))
}
185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969
185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969
Using New Function
New returns a new hash.Hash computing the SHA256 checksum.
For example,
package main
import (
"crypto/sha256"
"fmt"
)
func main() {
h := sha256.New()
h.Write([]byte("Hello"))
h.Write([]byte("World"))
fmt.Printf("%x\n", h.Sum(nil))
}
872e4e50ce9990d8b041330c47c9ddd11bec6b503ae9386a99da8584e9bb12c4
Generate SHA256 checksum of a file. See the following example:
package main
import (
"crypto/sha256"
"fmt"
"io"
"os"
)
func main() {
f, err := os.Open("ins.txt")
if err != nil {
// log.Fatal(err)
}
defer f.Close()
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
// log.Fatal(err)
}
fmt.Printf("%x\n", h.Sum(nil))
}
39866a50dfb27f5b96f075b3cbf9179096c87495983782427a0422c611a30e1e
In Golang, using the Sum function is the easiest way to get a MD5 hash from a string.
Using Sum Function
The md5.Sum() function returns the MD5 checksum of the data.
The following example should cover whatever you are trying to do:
package main
import (
"crypto/md5"
"encoding/hex"
"fmt"
)
func main() {
b := []byte("Hello")
out := md5.Sum(b)
fmt.Printf("%x\n", out)
// EncodeToString
fmt.Println(hex.EncodeToString(out[:]))
}
8b1a9953c4611296a827abf8c47804d7
8b1a9953c4611296a827abf8c47804d7
Using New Function
New returns a new hash.Hash computing the MD5 checksum. The Hash also implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to marshal and unmarshal the internal state of the hash.
For example,
package main
import (
"crypto/md5"
"fmt"
"io"
)
func main() {
h := md5.New()
io.WriteString(h, "Hello")
io.WriteString(h, "Word")
fmt.Printf("%x\n", h.Sum(nil))
}
04b6f86d49716af8d4f2edf01a309fc8
Generate MD5 checksum of a file. See the following example:
package main
import (
"crypto/md5"
"fmt"
"io"
"os"
)
func main() {
f, err := os.Open("ins.txt")
if err != nil {
// log.Fatal(err)
}
defer f.Close()
h := md5.New()
if _, err := io.Copy(h, f); err != nil {
// log.Fatal(err)
}
fmt.Printf("%x\n", h.Sum(nil))
}
3dca0fa76621281bfb7ffab47c860502
In Golang, using the IsPrivate function is the easiest way to check if IP address is in private network space.
Using IsPrivate Function
The IsPrivate() function reports whether ip is a private address, according to RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).
The following example should cover whatever you are trying to do:
// Go 1.17+
package main
import (
"fmt"
"net"
)
func main() {
ip := "1.1.1.1"
addr := net.ParseIP(ip)
fmt.Println(addr.IsPrivate())
ip = "10.3.4.0"
addr = net.ParseIP(ip)
fmt.Println(addr.IsPrivate())
}
false
true
This requires Go 1.17.
Using RFC1918
Here is an example with a list of RFC1918 address plus these others and a simple check against them as isPrivateIP(ip net.IP):
package main
import (
"fmt"
"net"
)
var privIPBlocks []*net.IPNet
func isPrivate(ip string) bool {
// init blocks
if len(privIPBlocks) == 0 {
for _, cidr := range []string{
"127.0.0.0/8", // IPv4 loopback
"10.0.0.0/8", // RFC1918
"172.16.0.0/12", // RFC1918
"192.168.0.0/16", // RFC1918
"169.254.0.0/16", // RFC3927 link-local
"::1/128", // IPv6 loopback
"fe80::/10", // IPv6 link-local
"fc00::/7", // IPv6 unique local addr
} {
_, block, err := net.ParseCIDR(cidr)
if err != nil {
panic(fmt.Errorf("parse error on %q: %v", cidr, err))
}
privIPBlocks = append(privIPBlocks, block)
}
}
addr := net.ParseIP(ip)
if addr.IsLoopback() || addr.IsLinkLocalUnicast() || addr.IsLinkLocalMulticast() {
return true
}
for _, block := range privIPBlocks {
if block.Contains(addr) {
return true
}
}
return false
}
func main() {
ip := "1.1.1.1"
fmt.Println(isPrivate(ip))
ip = "10.3.4.0"
fmt.Println(isPrivate(ip))
}
false
true
In PHP, using the $_SERVER variable is the easiest way to get the full URL.
Using $_SERVER Variable
$_SERVER is an array containing information such as headers, paths, and script locations.
The following example should cover whatever you are trying to do:
$link = "//{$_SERVER['HTTP_HOST']}{$_SERVER['REQUEST_URI']}";
// escaped
$link = htmlspecialchars($link, ENT_QUOTES, 'UTF-8');
echo $link;
//installmd.com/code/php/hash.php?p=1
In PHP, there are 2 ways to check if a string contains a specific word.
Using strpos Function
The strpos(string $haystack, string $needle, int $offset = 0): int|false function finds the numeric position of the first occurrence of needle in the haystack string. For example,
$str = "hello";
$pos = strpos($str, "l");
var_dump($pos);
$pos = strpos($str, "b");
var_dump($pos);
int(2)
bool(false)
Using preg_match Function
A simple match for are could look something like this:
$str = "hello";
$m = preg_match("/lo/i", $str);
var_dump($m);
$m = preg_match("/b/i", $str);
var_dump($m);
int(1)
int(0)
In PHP, there are 3 ways to delete an element from an array.
Using unset Function
The unset(mixed $var, mixed ...$vars): void function destroys the specified variables. For example,
$arr = ["a", "b", "d"];
unset($arr[1]);
print_r($arr);
Array
(
[0] => a
[2] => d
)
Note that when you use unset() the array keys won’t change. If you want to reindex the keys you can use array_values() after unset(), which will convert all keys to numerically enumerated keys starting from 0.
Using array_splice Function
The array_splice(): array function removes a portion of the array and replace it with something else.
$arr = ["a", "b", "d"];
array_splice($arr, 1, 1);
print_r($arr);
Array
(
[0] => a
[1] => d
)
Using array_filter Function
If you want to delete all elements with a specific value in the array you can use array_filter().
See the following example:
$arr = ["a", "b", "d", "b"];
$arr = array_filter($arr, function($ele){
return $ele !== "b";
});
print_r($arr);
Array
(
[0] => a
[2] => d
)
In Rust, using the thread::sleep_ms method is the easiest way to put the current thread to sleep.
Using sleep_ms Method
The thread::sleep_ms() method puts the current thread to sleep for at least the specified amount of time. For example,
use std::{thread, time::Duration, time::SystemTime};
fn main() {
println!("{:?}", SystemTime::now());
// Sleep
thread::sleep(Duration::from_millis(4000));
println!("{:?}", SystemTime::now());
}
SystemTime { tv_sec: 1653360055, tv_nsec: 949217277 }
SystemTime { tv_sec: 1653360059, tv_nsec: 949449668 }
In Rust, using the parse method is the easiest way to convert a string to int.
Using parse Method
The str::parse::<T>() method parses this string slice into another type. For example,
fn main() {
let s = "100".to_string();
println!("{}", s.parse::<i32>().unwrap());
match "10a".parse::<i32>() {
Ok(n) => println!("Ok"),
Err(e) => println!("{}", e),
}
}
100
invalid digit found in string
In Rust, there are 2 ways to check if a string contains whitespace.
Using char::is_whitespace
char::is_whitespace returns true if the character has the Unicode White_Space property.
You can pass char::is_whitespace to .contains():
fn main() {
println!("{}", "Hello World".contains(char::is_whitespace));
// a non-breaking space
println!("{}", "Hello\u{A0}World".contains(char::is_whitespace));
println!("{}", "Hello\taWorld".contains(char::is_whitespace));
}
true
true
true
Alternatively, you can use char::is_ascii_whitespace if you only want to match ASCII whitespace (space, horizontal tab, newline, form feed, or carriage return).
Using as_bytes Method
If you're only looking for ASCII whitespace:
fn main() {
let mut s = "Hello World";
println!("{}", s.as_bytes().iter().any(u8::is_ascii_whitespace));
// a non-breaking space
s = "Hello\u{A0}World";
println!("{}", s.as_bytes().iter().any(u8::is_ascii_whitespace));
s = "Hello\tWorld";
println!("{}", s.as_bytes().iter().any(u8::is_ascii_whitespace));
}
true
false
true
In Python, using the str.split method is the easiest way to split a string into a list
Using split Method
The str.split(sep=None, maxsplit=- 1) method returns a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. For example,
#!/usr/bin/python3
s = "a,b,c,d"
a = s.split(",")
print(a)
b = s.split(",", maxsplit=2)
print(b)
['a', 'b', 'c', 'd']
['a', 'b', 'c,d']
In Python, using the os.chdir method is the easiest way to set the current working directory
Using chdir Method
The os.chdir(path) method changes the current working directory to path. For example,
#!/usr/bin/python3
# Import module
import os
os.chdir("/data/site")
Prints the current working directory:
#!/usr/bin/python3
# Import module
import os
print(os.getcwd())
/home/data/python
In Python, there are 3 ways to get the position of a character.
Using find Method
The str.find(sub[, start[, end]]) method returns the lowest index in the string where substring sub is found within the slice s[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 if sub is not found. For example,
#!/usr/bin/python3
a = "There are two"
i = a.find('r')
print(i)
i = a.find('rb')
print(i)
3
-1
Using index Method
Like find(), but raise ValueError when the substring is not found.
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
a = "There are two"
i = a.index('r')
print(i)
i = a.index('rb')
3
ValueError: substring not found
Using List Comprehension
If you need to find all positions of a character in a string, you can do the following:
#!/usr/bin/python3
s = "There are two"
l = [pos for pos, char in enumerate(s) if char == 'r' ]
print(l)
[3, 7]
In Python, there are 2 ways to append integer to beginning of list.
Using insert Method
The list.insert() method inserts an item at a given position. The first argument is the index of the element before which to insert. For example,
#!/usr/bin/python3
a = [1, 2, 3]
a.insert(0, 5)
print(a)
[5, 1, 2, 3]
Using Unpack List
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
a = [1, 2, 3]
a = [5, *a]
print(a)
[5, 1, 2, 3]
In Python, using the timedelta object is the easiest way to calculate number of days between two given dates.
Using timedelta
If you have two date objects, you can just subtract them, which computes a timedelta object.
In this program, we will calculate number of days between two given dates.
#!/usr/bin/python3
# Import module
import datetime
d1 = datetime.date(2022, 5, 1)
d2 = datetime.date(2022, 5, 22)
delta = d2 - d1
print(delta.days)
21
In Python, there are 2 ways to delete the contents of a folder.
Using rmtree Method
The shutil.rmtree() method deletes an entire directory tree; path must point to a directory. For example,
#!/usr/bin/python3
# Import module
import os, shutil
def remove_dir(path):
for filename in os.listdir(path):
filepath = os.path.join(path, filename)
try:
if os.path.isfile(filepath) or os.path.islink(filepath):
os.unlink(filepath)
elif os.path.isdir(filepath):
shutil.rmtree(filepath)
except Exception as e:
print(e)
remove_dir("abcde")
Using glob Method
You can simply do this:
#!/usr/bin/python3
# Import module
import os, glob
files = glob.glob('abcde/*')
# files = glob.glob('abcde/*.txt')
for f in files:
os.remove(f)
In Python, there are 2 do case insensitive string comparison.
Using casefold Method
The str.casefold() method returns a casefolded copy of the string. Casefolded strings may be used for caseless matching. For example,
#!/usr/bin/python3
a = "Hello"
b = "heLLo"
print(a.casefold() == b.casefold())
print(a == b)
print("ß".casefold() == "SS".casefold())
True
False
True
The German lowercase letter 'ß' is equivalent to "ss".
Using lower Method
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
a = "Hello"
b = "heLLo"
print(a.lower() == b.lower())
print(a == b)
print('ß'.lower() == 'SS'.lower())
True
False
False
In Python, there are 2 ways to find out the number of CPUs.
Using multiprocessing Module
The multiprocessing.cpu_count() method returns the number of CPUs in the system. For example,
#!/usr/bin/python3
# Import module
import multiprocessing
cpus = multiprocessing.cpu_count()
print(cpus)
4
When the number of CPUs cannot be determined a NotImplementedError is raised.
Using os Module
The os.cpu_count() method returns the number of CPUs in the system. Returns None if undetermined.
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
# Import module
import os
cpus = os.cpu_count()
print(cpus)
4
In Python, there are 3 ways to get current time in milliseconds.
Using time Method
The time.time() method returns the time in seconds since the epoch as a floating point number. For example,
#!/usr/bin/python3
# Import module
import time
ms = round(time.time() * 1000)
print(ms)
1652865940186
Using time_ns Method
The time.time_ns() method returns time as an integer number of nanoseconds since the epoch.
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
# Import module
import time
ms = time.time_ns()
print(ms)
1652866090096069080
Using microsecond Attribute
For example,
#!/usr/bin/python3
# Import module
import datetime
t = datetime.datetime.now()
ms = t.microsecond
print(ms)
452195
In Python, there are 2 ways to convert all strings in a list to int.
Using map Method
You can convert all strings in a list to int using the map method. For example,
#!/usr/bin/python3
a = ["1", "2", "4", "5"]
b = list(map(int, a))
print(b)
[1, 2, 4, 5]
Using List Comprehension
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
a = ["1", "2", "4", "5"]
b = [int(i) for i in a]
print(b)
[1, 2, 4, 5]
In Python, there are 2 ways to capitalize the first letter of each word in a string.
Using title Method
The str.title() method returns a titlecased version of the string where words start with an uppercase character and the remaining characters are lowercase.
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
s = "method of a string"
print(s.title())
Method Of A String
Using capwords Method
Split the argument into words using str.split(), capitalize each word using str.capitalize(), and join the capitalized words using str.join(). For example,
#!/usr/bin/python3
# Import module
import string
s = "method of a string"
print(string.capwords(s))
Method Of A String
In Python, there are 2 ways to get the day of week given a date.
Using weekday Method
The weekday() method returns the day of the week as an integer, where Monday is 0 and Sunday is 6.
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
# Import module
import datetime
import calendar
d = datetime.datetime.today()
print(d.weekday())
# Monday
print(calendar.day_name[d.weekday()])
0
Monday
Using strftime Method
You can get the day of week given a date using the strftime Method. For example,
#!/usr/bin/python3
# Import module
import datetime
d = datetime.datetime.today()
print(d.strftime("%A"))
Monday
In Golang, there are 2 ways to escape the html.
Using EscapeString Function
The html.EscapeString() function escapes special characters like ", &, ' and ".
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"html"
)
func main() {
s := "<script>alert(1);</script>"
s = html.EscapeString(s)
fmt.Println(s)
}
<script>alert(1);</script>
Using HTMLEscapeString Funcion
The template.HTMLEscapeString() function returns the escaped HTML equivalent of the plain text data s. For example,
package main
import (
"fmt"
"text/template"
)
func main() {
s := "<script>alert(1);</script>"
s = template.HTMLEscapeString(s)
fmt.Println(s)
}
<script>alert(1);</script>
In Golang, there are 2 ways to change the current directory.
Using Dir Property
Usually if you need a command to run from a specific directory, you can specify that as the Dir property on the Command, for example:
package main
import (
"os/exec"
)
func main() {
cmd := exec.Command("ls", "-al")
cmd.Dir = "/home/user"
cmd.Run()
}
Using os.Chdir Function
The os.Chdir() function changes the current working directory to the named directory. If there is an error, it will be of type *PathError. For example,
package main
import (
"fmt"
"os"
)
func main() {
h, _ := os.UserHomeDir()
fmt.Println(h)
err := os.Chdir("/root/go")
if err != nil {
panic(err)
}
}
/root
This doesn't change the terminal location.
In Golang, using the Readdirnames function is the easiest way to check if directory on path is empty.
Using Readdirnames Function
The file.Readdirnames(n int) function reads the contents of the directory associated with file and returns a slice of up to n names of files in the directory, in directory order.
If n > 0, Readdirnames returns at most n names. In this case, if Readdirnames returns an empty slice, it will return a non-nil error explaining why. At the end of a directory, the error is io.EOF.
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"io"
"os"
)
func IsEmpty(path string) (bool, error) {
f, err := os.Open(path)
if err != nil {
return false, err
}
defer f.Close()
// OR f.Readdir(1)
_, err = f.Readdirnames(1)
if err == io.EOF {
return true, nil
}
return false, err
}
func main() {
fmt.Println(IsEmpty("a"))
fmt.Println(IsEmpty("b"))
}
true <nil>
false <nil>
In Golang, there are 3 ways to remove invalid UTF-8 characters from a string.
Using ToValidUTF8 Function
The strings.ToValidUTF8() function returns a copy of the string s with each run of invalid UTF-8 byte sequences replaced by the replacement string, which may be empty.
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"strings"
)
func main() {
s := "a\xc5bd"
s = strings.ToValidUTF8(s, "")
fmt.Printf("%q\n", s)
}
"abd"
Using Map function
In Go 1.11+, it's also very easy to do the same using the Map function and utf8.RuneError like this:
package main
import (
"fmt"
"strings"
"unicode/utf8"
)
func main() {
s := "a\xc5bd"
valid := func(r rune) rune {
if r == utf8.RuneError {
return -1
}
return r
}
s = strings.Map(valid, s)
fmt.Printf("%q\n", s)
}
"abd"
Using Range
For example,
package main
import (
"fmt"
"unicode/utf8"
)
func ToValid(s string) string {
if utf8.ValidString(s) {
return s
}
v := make([]rune, 0, len(s))
for i, r := range s {
if r == utf8.RuneError {
_, size := utf8.DecodeLastRuneInString(s[i:])
if size == 1 {
continue
}
}
v = append(v, r)
}
return string(v)
}
func main() {
s := "a\xc5b\x8ad"
s = ToValid(s)
fmt.Printf("%q\n", s)
}
"abd"
In Golang, there are 2 ways to check if a file is a valid image.
Using DetectContentType Function
The http.DetectContentType() function implements the algorithm described at https://mimesniff.spec.whatwg.org/ to determine the Content-Type of the given data. It considers at most the first 512 bytes of data. DetectContentType always returns a valid MIME type: if it cannot determine a more specific one, it returns "application/octet-stream".
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"net/http"
"os"
)
func main() {
f, _ := os.Open("icon.png")
defer f.Close()
buff := make([]byte, 512)
if _, err := f.Read(buff); err != nil {
// panic()
fmt.Println(err)
}
s := http.DetectContentType(buff)
fmt.Println(s)
}
image/png
Using Magic Number
What is usually done is checking if the file has the right magic number for the image file format you want. While this test is not super accurate, it is usually good enough.
package main
import (
"fmt"
"os"
"strings"
)
var magicTable = map[string]string{
"\xff\xd8\xff": "image/jpeg",
"\x89PNG\r\n\x1a\n": "image/png",
"GIF87a": "image/gif",
"GIF89a": "image/gif",
}
func DetectType(b []byte) string {
s := string(b)
for key, val := range magicTable {
if strings.HasPrefix(s, key) {
return val
}
}
return ""
}
func main() {
f, _ := os.Open("icon.png")
defer f.Close()
buff := make([]byte, 512)
if _, err := f.Read(buff); err != nil {
// panic()
fmt.Println(err)
}
s := DetectType(buff)
fmt.Println(s)
}
image/png
Matching an image type pattern
An image MIME type is a MIME type whose type is "image".
Byte Pattern
Image MIME Type
00 00 01 00
image/x-icon
00 00 02 00
image/x-icon
42 4D
image/x-icon
47 49 46 38 37 61
image/gif
47 49 46 38 39 61
image/gif
52 49 46 46 00 00 00 00 57 45 42 50 56 50
image/webp
89 50 4E 47 0D 0A 1A 0A
image/png
FF D8 FF
image/jpeg
In Golang, there are 2 ways to count characters in a string.
Using RuneCountInString Function
Straight forward natively use the utf8.RuneCountInString()
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
s := "Hello,世界"
i := utf8.RuneCountInString(s)
fmt.Println(i)
}
8
Using strings.Count Function
The strings.Count() function counts the number of non-overlapping instances of substr in s. If substr is an empty string, Count returns 1 + the number of Unicode code points in s. For example,
package main
import (
"fmt"
"strings"
)
func main() {
s := "Hello,世界"
i := strings.Count(s, "l")
fmt.Println(i)
// 1 + number
i = strings.Count(s, "")
fmt.Printf("points: %d\n", i)
fmt.Printf("length: %d\n", len(s))
}
2
points: 9
length: 12
In Golang, using the DecodeRuneInString function is the easiest way to remove the first character of a string.
Using DecodeRuneInString Function
The following example should cover whatever you are trying to do:
package main
import (
"fmt"
"unicode/utf8"
)
func trimFirstRune(s string) string {
_, i := utf8.DecodeRuneInString(s)
return s[i:]
}
func main() {
fmt.Println(trimFirstRune("Hello"))
fmt.Println(trimFirstRune("世界"))
}
ello
界
Using Range
You can use range to get the size of the first rune and then slice:
package main
import "fmt"
func trimFirstRune(s string) string {
for i := range s {
if i > 0 {
return s[i:]
}
}
return ""
}
func main() {
fmt.Println(trimFirstRune("Hello"))
fmt.Println(trimFirstRune("世界"))
}
ello
界
In Golang, using the buffer.Reset function is the easiest way to clear a bytes.Buffer
Using buffer.Reset Function
The buffer.Reset() function resets the buffer to be empty, but it retains the underlying storage for use by future writes. Reset is the same as Truncate(0).
See the following example:
package main
import (
"bytes"
"fmt"
)
func main() {
var b bytes.Buffer // A Buffer needs no initialization.
b.Write([]byte("Hello "))
b.ReadByte()
fmt.Printf("%v\n", b)
// Clear
b.Reset()
fmt.Printf("%v\n", b)
}
{[72 101 108 108 111 32] 1 -1}
{[] 0 0}
In Golang, using the %p verbs is the easiest way to print the memory address of a slice.
Using fmt.Printf Function
Pointer:
%p base 16 notation, with leading 0x. The %b, %d, %o, %x and %X verbs also work with pointers,
formatting the value exactly as if it were an nteger.
See the following example:
package main
import "fmt"
func main() {
a := []int{1, 2, 3}
b := a[:]
fmt.Printf("&a: %p\n", &a)
fmt.Printf("&b: %p\n", &b)
fmt.Printf(" a: %p\n", a)
}
&a: 0xc0000ac018
&b: 0xc0000ac030
a: 0xc0000ba000
In Python, using the os.environ variable is the easiest way to set environment variables
Using os.environ Variable
os.environ behaves like a python dictionary, so all the common dictionary operations can be performed. In addition to the get and set operations mentioned in the other answers, we can also simply check if a key exists. The keys and values should be stored as strings.
For example,
#!/usr/bin/python3
# Import module
import os
# Environment variables must be strings
os.environ["GIT_PATH"] = "/usr/local"
print(os.environ["GIT_PATH"])
/usr/local
Python Errors
str expected, not int:
os.environ["GIT_VER"] = 1
File "/usr/local/lib/python3.10/os.py", line 756, in encode
raise TypeError("str expected, not %s" % type(value).__name__)
TypeError: str expected, not int
In Python, there are 2 ways to get a list of all subdirectories in the current directory.
Using os.walk Function
The os.walk() method generates the file names in a directory tree by walking the tree either top-down or bottom-up.
The following example:
#!/usr/bin/python3
# Import module
import os
fs = os.walk(".")
for root, dirs, files in fs:
print(files)
['demo.py', 'start.sh', 'file.txt']
['a.txt']
Using glob Function
using the glob function is the easiest way to get a list of all subdirectories in the current directory.
#!/usr/bin/python3
# Import module
import glob
fs = glob.glob("./*/*", recursive = True)
for f in fs:
print(f)
./a/a.txt
Don't forget the trailing / after the *.
In Python, there are 3 ways to get key by value in dictionary.
Using keys Function
Basically, it separates the dictionary's values in a list, finds the position of the value you have, and gets the key at that position.
The following example:
#!/usr/bin/python3
d = {"a": 1, "b": 2, "c": 1}
key = list(d.keys())[list(d.values()).index(1)]
print(key)
a
Using List Comprehension
Using a list comprehension is the most Pythonic way:
#!/usr/bin/python3
d = {"a": 1, "b": 2, "c": 1}
keys = [key for key, val in d.items() if val == 1]
print(keys)
['a', 'c']
Using dict Method
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
d = {"a": 1, "b": 2, "c": 1}
key = dict((v,k) for k,v in d.items()).get(1)
print(key)
c
In Python, there are 3 ways to remove all empty strings from a list of strings.
Using filter Function
The filter(function, iterable) function constructs an iterator from those elements of iterable for which function returns true.
The following example:
#!/usr/bin/python3
a = ["a", "", " ", "c", " "]
# b = list(filter(bool, a))
# b = list(filter(len, a))
b = list(filter(None, a))
print(b)
b = list(filter(str.strip, a))
print(b)
['a', ' ', 'c', ' ']
['a', 'c']
Using List Comprehension
Using a list comprehension is the most Pythonic way:
#!/usr/bin/python3
a = ["a", "", " ", "c", " "]
b = [x for x in a if x.strip()]
print(b)
['a', 'c']
Using join Method
The following example should cover whatever you are trying to do:
#!/usr/bin/python3
a = ["a", "", " ", "c", " "]
b = ' '.join(a).split()
print(b)
['a', 'c']
In Python, there are 3 ways to get the system hostname.
Using gethostname Method
The socket.gethostname() method returns a string containing the hostname of the machine where the Python interpreter is currently executing. For example,
#!/usr/bin/python3
# Import module
import socket
print(socket.gethostname())
installmd.com
Using platform Module
The Path.resolve() method returns the computer’s network name (may not be fully qualified!). An empty string is returned if the value cannot be determined.
#!/usr/bin/python3
# Import module
import platform
print(platform.node())
installmd.com
Using uname Method
You will probably load the os module anyway, so another suggestion would be:
#!/usr/bin/python3
# Import module
import os
print(os.uname()[1])
print(os.uname())
installmd.com
posix.uname_result(sysname='Linux', nodename='installmd.com', release='3.10.0-1160.el7.x86_64', version='#1 SMP Mon Oct 19 16:18:59 UTC 2020', machine='x86_64')